精华内容
下载资源
问答
  • 如何给函数定义表达式
    2020-01-09 16:23:14

    匿名函数:函数如果没有名字,就是匿名函数 *
    函数的另一种定义方式
    函数表达式:
    把一个函数给一个变量,此时形成了函数表达式
    var 变量=匿名函数;
    例子: * var f1=function (){ * * };
    如果是函数表达式,那么此时前面的变量中存储的就是一个函数,而这个变量就相当于是一个函数,就可以直接加小括号调用了 ** f1(); **
    注意: * 函数表达式后面,赋值结束后,要加分号 * * * * 函数定义: * *1. 函数声明–函数定义 function 函数名(){ * 函数体 * } * ** */
    函数的自调用,没有名字,调用—声明的同时,直接调用 一次性
    匿名函数不能直接调用

    函数声明会被覆盖
    例如:function f1() {
    console.log(“小烈爱吃水果”);
    }
    f1();
    function f1() {
    console.log(“我好猥琐哦”);
    }
    f1();
    输出的结果是我好猥琐哦 我好猥琐哦

    函数表达式不会被马上覆盖
    按照变量的赋值效果一样
    var f2 = function () {
    console.log(“24K纯帅”);
    };
    f2();
    f2 = function () {
    console.log(“我爱湮灭”);
    };
    f2();
    输出 24K纯帅 我爱湮灭
    这原因个人猜测应该和预解析有关

    //函数自调用
    (function () {
    console.log(“阿涅哈斯诶呦”);
    })();

    更多相关内容
  • 使用javascript多年,写过无数函数,今天却才真正弄明白两种函数定义的区别,真是悲剧,写下这个随笔, 以时刻提醒自己要打好基础 , 一大把年纪了, 不能继续懵懵懂懂了。 通常我们会看到以下两种定义函数的方式: ...
  • 函数声明的方法定义函数,函数可以在函数声明之前调用,而函数表达式函数只能在声明之后调用. 3).以函数声明的方法定义函数并不是真正的声明,它们仅仅可以出现在全局中,或者嵌套在其他的函数中,但是它们不能...
  • 函数声明的方法定义函数,函数可以在函数声明之前调用,而函数表达式函数只能在声明之后调用. 3).以函数声明的方法定义函数并不是真正的声明,它们仅仅可以出现在全局中,或者嵌套在其他的函数中,但是它们不能...
  • 函数表达式

    千次阅读 2020-05-19 12:48:12
    一、函数表达式定义 函数的方式有两种:一种是函数声明,另一种是函数表达式函数声明语法格式如下: function functionName(arg0,arg1,arg2){ //函数体 } 关于函数声明,有一个重要的特征就是函数声明提升,意思...

    一、函数表达式定义

    函数的方式有两种:一种是函数声明,另一种是函数表达式函数声明语法格式如下:

    function functionName(arg0,arg1,arg2){
    //函数体
    }

    关于函数声明,有一个重要的特征就是函数声明提升,意思是在执行代码之前会先读取函数声明
    函数表达式语法格式如下:

    var functionName=function(arg0,arg1,arg2){
    //函数体
    }

    二、递归

    递归函数是一个函数通过名字调用自身情况构成的经典的递归函数

    function factorial(num){
    if(num<=1){
    return 1
    }else{
    return num*factorial(num-1)
    }
    }
    console.log(factorial(3))

    但是下列代码会导致它出现问题

    var anotherFactial=factorial;
    factorial=null;
    console.log(anotherFactial(4))

    此时解决的方法有两个

    //方法一
    function factorial(num){
    if(num<=1){
    return 1;
    }else{
    return num*arguments.callee(num-1)}}//但是严格模式下不能通过脚本访问arguments.callee,故可以使用方法二更加保险
    //方法二:
    var factorial=(function f(num){if(num<=1){
    return 1;
    }else{return num*f(num-1)
    }
    }
    )

    三、闭包

    闭包是指有权访问另一个函数作用域的变量的函数,常见的创建闭包的常见方式,就是在一个函数内部创建另有一个函数

    function createComparisionFunction(propertyName){
    return function(object1,object2){
    var value1=object1[propertyName];
    var value2=object2[propertyName];
    if(value1<value2){
    return -1 
    }else if(value1>value2){
    return 1 
    }else{
    return 0
    }
    }
    }

    闭包的执行过程:某个函数被调用时,会创建一个执行环境及相应的作用链域。然后使用arguments和其他命名参数的值来初始化函数的活动对象,但在作用域中,外部函数活动对象始终处于第二位,外部函数的外部函数的活动对象处于第三位…知道作用链域终点的全局执行环境。

    下面来讨论一下函数执行完毕后闭包域其他普通函数的不同之处
    普通函数:函数作用域及其所有变量都会在函数执行结束后被销毁
    在这里插入图片描述

    闭包:函数作用域会一直在内存中保存到闭包不存在为止在这里插入图片描述

    3.1、闭包与变量

    闭包只能取得包含函数中任何变量的最后一个值闭包保存着的是整个变量对象,而不是某个特殊的函数

    function createFunctions(){
    var result=new Array()
    for(var i=0;i<10;i++){
    result[i]=function(){
    return i
    }
     }
     return result
     }
     var funcs = createFunctions();
     for (var i=0; i < funcs.length; i++){
     console.log(funcs[i]());//10
     }

    但是,我们乐意创建另一个匿名函数强制让闭包的行为符合预期

    function createFunctions(){
    var result=new Array();
    for(var i=0;i<10;i++){
    result[i]=function(num){
    return function(){
    return num
    }
    }(i)
    }
    return result
    }
    var funcs = createFunctions();
    for (var i=0; i < funcs.length; i++){
    console.log(funcs[i]());//0,1,2,3,4,5,6,7,8,9            }
    

    3.2、关于this对象

    在闭包中,匿名函数的执行环境具有全局性,因此其this对象通常指向window

    var name="The Window";
    var object={
    name:"My Object",
    getNameFunc:function(){
    return function(){
    return this.name;
    }
    }
    }
    console.log(object.getNameFunc()())//"The window"
    

    为什么匿名函数没有取得其包含作用域(或外部作用域)的this对象呢
    因为每个函数在被调用的时候都会自动取得两个特殊的变量:this和arguments。内部函数在搜索这两个变量时,只会搜索到其活动对象为止,因此永远不可能直接访问外部函数中的这两个变量

    但是,将该对象的引用保存到另一个闭包能访问的变量中

      var name="The Window";
      var object={name:"My Object",
      getNameFunc:function(){
      var that=this;
      return function(){
      return that.name;
      }
      }
      }
      console.log(object.getNameFunc()())//"The window"

    3.3、内存泄漏

    四、模仿块级作用域

    function(){
    //这里是块级作用域
    })();

    但是注意不能这样做:

    function(){
    //这里是块级作用域
    }();//出错

    这是因为js将function关键字当作一个函数声明的开始,而函数声明后面不可以跟圆括号
    然而,函数表达式后面可以跟圆括号,要将函数声明转换成函数表达式,只要给它加上一对圆括号或者改为函数表达式

    function(){
    })()
    
    var fun=function(){
    }()
    function outputNumbers(count){
    (function(){
    for(var i=0;i<count;i++){
    console.log(i)//0,1,2,3
    }
    })();
    console.log(i)//error
    }
    outputNumbers(4)

    五、私有变量

    我们把有权访问私有变量和私有方法的公有方法称为特权方法
    有两种方法在对象上创建特权方法:第一种是在构造函数中定义特权方法,

    function myObject(){
    var privateVaeriable=10;
    function privateFunction(){
    return false;
    }
    this.publicMethod=function(){
    privateVaeriable++;
    return privateFunction();
    }
    }

    5.1、静态私有变量

    实例都会创建同样一组新方法,故通过静态私有变量来解决:

     (function(){
     var privateFunction=10;
     function privateFunction(){
     return false;
     }
     MyObject=function(){//通过函数表达式来定义构造函数,因此MyObject成为了一个全局函数,同样初始化未声明的变量,总会创建一个全局变量,MyObject就成了一个全局变量,能够在私有作用域之外被访问
    }
    MyObject.prototype.publicMethod=function(){
    privateVariable++;
    return privateFunction()
    }
    })

    这个模式与前面在构造函数中的主要区别:私有变量和函数是由实例共享的,由于特权方法是在原型上定义的,因此所有的实例使用同一个函数

     (function(){
     var name='';
     Person=function(value){
     name=value;
     }
     Person.prototype.getName=function(){
     return name;
     }
     Person.prototype.setName=function(value)
     {
     name=value;
     }
     })();
     var person1=new Person("Nicholas");
     var person2=new Person("Michael");
     console.log(person1.getName());//"Nicholas"
     person1.setName("Greg");
     console.log(person1.getName())//"Greg"
     console.log(person2.getName())//"Greg"

    但是原型方法由所有实例公用,在一个实例上调用setName()会影响所有实例。结果就是所有的实例都会返回相同值
    所以延伸出下面的模块模式

    5.2、模块模式

    为单例创建变量和特权方法

      var singleton=function(){
      //私有变量和私有函数          
      var privateVariable=10;
      function privateFunction(){
      return false;
      }
      //特权/共有方法和属性
      return {
      publicProperty:true,
      publicMethod:function(){
      privateVariable++;
      return privateFunction()
      }
      }
      }();
    

    这种模式在需要对单例进行某些初始化,同时也需要维护某私有变量是非常有用的
    简言之,如果必须创建一个对象并以某些数据对其进行初始化,同时还要公开一些能访问这些私有数据的方法,就可以使用模块模式

    5.3、增强的模块模式

    在返回对象之前加入对其增强的代码,这种增强的模块模式适合哪些单例必须是某种类型,同时还必须添加某些属性和方法对其加以增强的情况

    var singleton=function(){
    //私有变量和私有函数
    var privateVariable=10;
    function privateFunction(){
    return false;
    }
    //创建对象 
    var object=new CustomType();
    //添加特权/共有属性和方法
    object.publicProperty=true;
    object.publicMethod=function(){
    privateVariable++;
    return privateFunction()
    }
    return object
    }()
    展开全文
  •  定义函数的方式有两种:一种是函数声明,另一种就是函数表达式;  1.1 函数声明 function functionName(arg){ //函数体 }  关于函数声明,它有一个重要特征就是函数声明提升,意思就是在执行代码之前会先读取...
  • 复合函数定义函数表达式的求法.doc
  • 函数声明与函数表达式

    千次阅读 2020-03-21 12:17:20
    定义一个函数的方法主要有三种 函数声明、函数表达式、new Function构造函数函数声明与函数表达式定义函数较为常用,构造函数的方式可以将字符串定义函数 函数声明 函数声明会将声明与赋值都提前,也就是整个...

    函数声明与函数表达式

    定义一个函数的方法主要有三种 函数声明、函数表达式、new Function构造函数,函数声明与函数表达式定义的函数较为常用,构造函数的方式可以将字符串定义为函数。

    函数声明

    函数声明会将声明与赋值都提前,也就是整个函数体都会被提升到作用域顶部。

    s(); // 1
    function s(){
        console.log(1);
    }
    

    也就是说,在某个作用域中定义的函数可以在这个作用域的任意位置调用,整个函数体都将被提前,当然也有不一样的情况:

    console.log(s); // undefined // 函数的声明提升但是并未赋值函数体
    console.log(ss); // Uncaught ReferenceError: ss is not defined // 打印未定义的ss是为了对比说明函数的声明提升
    s(); // Uncaught TypeError: s is not a function
    if(1){
        function s(){
            console.log(1);
        }
    }
    

    此处可以看到函数的声明被提升,但是函数体并未被提升,JS只有函数作用域与全局作用域以及ES6引入的letconst块级作用域,此处if不存在作用域的问题,为同一作用域,但是由于解释器在预处理期无法确定if里面的内容,所以只对函数声明的变量进行了提升,而并未将函数体赋值。

    函数表达式

    函数表达式只会提升变量的声明,本质上是变量提升并将一个匿名函数对象赋值给变量。

    console.log(s); // undefined
    var s = function s(){
        console.log(1);
    }
    console.log(s);  // f s(){console.log(1);}
    

    由此来看,直接进行函数声明与函数表达式声明的函数之间就存在一个优先级关系。

    var s = function(){
        console.log(0);
    }
    function s(){
        console.log(1);
    }
    s(); // 0
    

    JS中函数是第一等公民,在《你不知道的JavaScript》(上卷)一书的第40页中写到,函数会首先被提升,然后才是变量。也就是说,同一作用域下提升,函数会在更前面。即在JS引擎的执行的优先级是函数声明、变量声明、变量赋值。

    function s(){ //函数声明
        console.log(1);
    }
    
    var s; // 变量声明
    
    // 函数已声明`a` 相同的变量名`var`声明会被直接忽略
    console.log(s); // f s(){...}  
    
    s = function(){ // 变量赋值
        console.log(0);
    }
    
    s(); // 0
    

    new Function

    new Function的方式可以将字符串解析为函数。

    var s = new Function("a","b","console.log(a,b);");
    s(1,2); // 1,2
    console.log(s.__proto__ === Function.prototype); //true
    function ss(){} // 声明的函数都是Function的一个实例
    console.log(ss.constructor === Function); // true
    console.log(ss.__proto__ === Function.prototype); // true
    

    new Functioneval也有所不同,其对解析内容的运行环境的判定有所不同。

    // eval中的代码执行时的作用域为当前作用域,它可以访问到函数中的局部变量,并沿着作用域链向上查找。
    // new Function中的代码执行时的作用域为全局作用域,无法访问函数内的局部变量。
    var a = 'Global Scope';
    (function b(){
        var a = 'Local Scope';
        eval("console.log(a)"); //Local Scope
        (new Function("console.log(a)"))() //Global Scope
    })();
    

    每日一题

    https://github.com/WindrunnerMax/EveryDay
    

    参考

    https://www.cnblogs.com/echolun/p/7612142.html
    https://www.cnblogs.com/miacara94/p/9173843.html
    https://blog.csdn.net/qq_41893551/article/details/83011752
    
    展开全文
  • js的解析器对函数声明与函数表达式并不是一视同仁...对于函数声明,js解析器会优先读取,确保在所有代码执行之前声明已经被解析,而函数表达式,如同定义其它基本类型的变量一样,只在执行到某一句时也会对其进行解析,
  • 函数名称是函数声明的必需组成部分,这个函数名称相当于一个变量,新定义函数会复制这个变量,以后函数的调用都需要通过这个变量进行。而对于函数表达式来说,函数的名称是可选的,例如下面的例子: var sub = ...
  • JavaScript函数定义表达式,JavaScript属性访问表达式
    4.3 函数定义表达式
    函数定义表达式定义一个JavaScript函数,表达式的值是这个新定义的函数。
    var square = function(x){return x*x;}

    4.4 属性访问表达式

    属性访问表达式得到一个对象属性或者一个数组属性,JavaScript为属性访问定义了两种语法:
        expression.identifier                        ------1
        expression[expression]                    -------2
    1是表达式后面跟随一个句号和标识符,表达式指定对象,标识符则指定需要访问的属性的名称。
    2是使用方括号,方括号内是另外一个表达式,适用于对象和数组,方括号内的表达式指定要访问的属性的名称或者代表要访问数组元素的索引。
          不管使用1还是2,在.和[之前的表达式总是会首先计算,如果计算结果为null或者undefined,表达式会抛出一个类型错误异常。,因为null和undefined不包含任何属性。如果运算结果不是对象或者数组,JavaScript会将其转换对象。如果对象表达式后面跟随句号和标识符,则会查找由这个标识符所指定的属性的值,并将其作为整个表达式的值返回。如果对象表达式后跟随一对方括号,则会计算方括号内的表达式的值并将其转换成字符串。
     
        使用区分:
    • .identifier 只使用于要访问的属性名是合法的标识符,并且要知道需访问的属性的名字
    • 如果属性是保留字或者包含空格和标点符号,或是一个数字,则必须使用方括号的写法;当属性名是通过计算得出的值而不是固定值时,也必须使用方括号的写法。


    展开全文
  • 函数通常有2种创建方式:函数声明和函数表达式。 区别: 1.函数声明必须包含名称,函数...在JavaScript中,有两种方式可以定义一个函数,一个是函数声明,一个是函数表达式。 一 函数声明 函数声明的语法如下: func
  • 即使在函数定义之前调用它也没问题。 foo(); // Works because foo was created before this code runs function foo() {} 因为我打算专门写篇介绍作用域的文章,所以这里就不详述了。 函数表达式 对于函数声明,...
  • 函数定义带来的错误 虽然 function () {…} 看上去像是一个函数声明,但是由于没有函数名,它的本质其实是一个函数表达式。我们看下规范中对于函数声明与函数表达式的定义: 可以看出来,函数声明是必须带有函数名...
  • 下面小编就为大家带来一篇浅析函数声明和函数表达式——函数声明的声明提前。小编觉得挺不错的,现在分享大家,也大家做个参考。
  • 原文地址 我的简单理解就是通过一行代码定义一个函数 ...通过lambda表达式定义一个函数 fun = lambda x, y: x+y if x<y else x-y print(fun(1,3)) # 4 lambda表达式与map函数结合方便的进行数据处理 map()
  • 其实js支持函数闭包的主要...vasufunction(numnum)returnunum}//函数表达式定义 vasuneFunction(“num””num””returnunum”)//Functio构造函数 在分析闭包之前我们先来看看,定义和调用函数容易犯的错误。 例1: s
  • 函数声明式和函数表达式区别

    万次阅读 2019-06-17 19:51:51
    javascript中声明函数的方法有两种:...以函数声明的方法定义函数,函数可以在函数声明之前调用,而函数表达式函数只能在声明之后调用。 3).以函数声明的方法定义函数并不是真正的声明,它们仅仅可以出现在全局中...
  • 在javascript中,函数有两种定义写法,函数定义表达式和函数声明,其例子分别如下所示:var test = function(x){ return x; } function test(x){ return x; } 尽管函数定义表达式和函数声明语句包含相同的函数...
  • 主要介绍了JS定义函数的几种常用方法,结合实例形式总结分析了javascript函数表达式、Lambda 表达式、对象方法等常见函数定义操作技巧,需要的朋友可以参考下
  • 大家好鸭????,前几期的EduCoder题解,阅读量超过了之前的好多文章!...题目描述:有如下表达式 s = 1 + 1 / 3 + (1 * 2) / (3 * 5) + (1 * 2 * 3) / (3 * 5 * 7) + .... + (1 * 2 * 3 * .... * n) / (3 * 5 * 7 *
  • 使用 lambda 编写的代码更加简洁紧凑,但是 lambda 函数支持的功能却是十分有限的,目前 PEP8 已经不建议使用 lambda,而是推荐使用 def 去定义一个函数,即便如此,作为 Python 程序员,认识和了解该匿名函数还是有...
  • 函数声明与函数表达式的提升问题

    千次阅读 2019-03-29 16:59:51
    首先上图 ...而函数b是函数表达式,执行的是变量提升,实际效果是 var b; b(); b = function() {} 由于b已经声明了,所以不会报错ReferenceError,而是TypeError。 另外补充一点,函数声明和变...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 778,902
精华内容 311,560
关键字:

如何给函数定义表达式