JS - 函数，Math,number

函数分为：关键字function

匿名函数 — 没有名字的函数
有名函数 — 有名字的函数

<body>

    <div></div>

    <script>
　　　　　// 匿名函数 -

        var oTar = document.getElementsByTagName("div");

        oTar[0].onclick=function () {

            alert(1)

        };

　　　　　// 有名函数  — Fn 第一个字母大写

        function Fn() {

            alert(1)

        }

        Fn()       
　　　　 document.onclick=Fn;  // 不加括号函数不马上执行，点击后再执行。 加括号不点击就执行了
　　　　　　　　　　// 这里document 选中body

　　</script> 
</body>

定义函数：

    <script>

        // ---------------------------

        // 定义函数：

        Fn();    // 定义的函数在前面后面都可以调用

        function Fn() {

            alert(1)

        }

        Fn();      //  定义的函数后面

    </script>

定义函数的一些 骚写法：

    <script>

        ~function () {

            alert(1)    // 匿名函数加上() + - ! ~ 变成函数表达式，在表达式后面加上（）调用

        }();

        +function () {

            alert(2)

        }();

        -function () {

            alert(3)

        }();

        !function () {

            alert(4)

        }();

        (function () {

           alert(5)

        })() ;    // 常见一点

        (function () {

           alert(6)

        }())

    </script>

函数表达式：

    <script>

       // 函数表达式

        Fn1();     // 函数表达式前面不能执行 未定义

        var Fn1 = function () {

            alert(1)

        };

        Fn1();     // 后面才执行

    </script>

函数的参数:

    <script>

 // 1. 实参

        function Fn(x) {

            alert(x)

        }

        Fn(1);

 // 2. 形参

        var a=2;

        Fn1(a);

        function Fn1(x) {

            //-- var x;  // 函数内 var 一个x，没有给值。传值进来就有值了

            alert(x)   // x 是局部变量，命名规则和var相同，无中生有

        }

 // 3. 不定参

            // 参数一一对应

        sum(2,2);

        function sum(x,y) {

            alert(x+y)

        }

            // 实参 多于 形参, 是参合形参对应，多余的实参存于函数arguments内

        sum1(1,2,3,4);

        function sum1(x,y) {

            alert(x+y);

            alert(arguments.length);   // 4

            alert(arguments[3])   // 4 参数都存在arguments内

        }

            // 实参少于形参 ，  NaN 非法

        sum2(2,2);

        function sum2(x,y,z) {

            alert(x+y+z);   // x,y 有值 , NaN

            alert(z)  //  z没有值 undefined，可以给z默认值

        }

            // 给默认值

        sum3(1,2);

        function sum3(x,y,z) {

            // 给默认值

            x = x || 0;  // 1 传入值就等于本身，=(true).  || 遇真就停

            y = y || 0;  // 2

            z = z || 1;  // 没有值传入 =(false). z = 1

            alert(x+y+z)   // 1+2+1

        }

    </script>

函数的返回值：

    <script>

        // 函数的返回值 默认undefined

        function Fn() {

            oTag[0].innerHTML="zzzz";

            return "ha";   // 设置返回值

        }

        a =Fn();  // a 接受返回值

        alert(a)  // "ha"

    </script>

函数的作用域：

javascript解析顺序
    1.（定义）先解析var function 参数
        a.该步骤的var只定义变量，后面的=赋值不解析
        b.该步骤的函数只定义函数，函数的执行不解析
        c.重名的只留一个，var 和函数重名  函数优先
    2.（执行）再从上至下执行其他代码

    作用域：
        作用：读写
        域：范围，区域
    解析：
        从上至下
            1 找 var 定义函数 参数
            2 执行

    <script>

　　　　　　　alert(a);   // 这三行的执行顺序 1.先var a;不给值 undefined

            var a=1;    //  2. 从上到下执行 第一个alert(a) a没值 undefined

            alert(a);   //                 a=1,  在第三行的alert(a) 1

    </script>

　　1.函数里var 变量a

    </script>

            var a=1;               //1.找 var a; undefined

            function Fn() {       //         Fn=函数体

                alert(2);           // 2.执行 a=1,alert(2)

                var a=3                     // 1)找var a;undefined,

            }                               // 2) 执行  a=3

            Fn();

            alert(a);               //      alert(a) 弹出1

    </script>

　　1 和 2 有无var的区别

　　2.函数里修改全局a的值

    </script>

            var a=1;               //1.找 var a; undefined

            function Fn() {       //         Fn=函数体

                alert(2);           // 2.执行 a=1,alert(2)

                a=3                 //       a=3,函数体没有变量a,它会修改

            }                       //    外面的a=1  => 3

            Fn();

            alert(a);      // 弹出 3

    </script>

数字方法：Math

/*
Math 数学函数
Math.pow(16, 2)——十六的平方 256
Math.round(5.5)——四舍五入（整数）
Math.ceil(0.2)——向上取整
Math.floor(0.9)——向下取整
Math.max()——取参数中最大的值
Math.min()——取参数中最小的值
Math.random()——0-1的随机数        0--1
Math.random()*m+n       //  *m => 0*m--1*m  ,+n => 0+n--m+n
                                                   生成 n ~ (m+n)
Math.PI——π
Math.abs()——求绝对值
*/

number:

/*
  js的六大数据类型
      number
      string
      boolean
      function
      undefined
      object
  number数字
      在js里面的小数和整数统一都是数字，-2^53-2^53，超出范围之后精度就会不准确
  number方法
      Number()——参数中必须能被转换成数字，否则返回NaN:
      parseInt(解析的参数)——将参数转换为数字，整数部分遇到不
      是数字就停
      parseFloat()——将参数转换为数字，不是数字就停，否则直到
      小数部分遇到不是数字就停
       Num.toFixed(n)——四舍五入保留n位小数
       NaN（Not a　Number）
          NaN 不等于自己
*/

巴特西

JS - 函数，Math,number

最新文章

热门文章