Question

我需要一些帮助来了解JavaScript中的闭包。我需要制作一个在数组元素之间插入指定分隔符的函数（function1），如果未指定分隔符，则插入一个逗号。我已经尝试过这种方法，但是无法正常工作。

function function1(separator)
{
    return function(elements)
    {
        for (var i = 0; i < elements.length; i++)
        return (`${elements}`+ separator);
    };
}


var ex1 = function1("/");
ex1("One"); 
ex1("Two"); 


var ex2 = function1("*");
ex2("One"); 
ex2("Two"); 


var ex3 = function1();
ex3("One");
ex3("Two");


console.log("ex1 is" + ex1() );
console.log("ex2 is " + ex2() );
console.log("ex3 is " + ex3() );

输出应为

ex1 is One/Two
ex2 is One*Two
ex3 is One,Two

Answer 1

您的功能就在那里。缺少的主要方面是使用闭包来保存元素。

如果外部函数定义了一个数组，那么内部函数将可以访问该数组。那就是关闭。然后，返回的函数将使用单个元素并将其推入components数组。

function function1(separator){
    let components = []
    return function(element){
        // this function, even after returned, will have access to components
        // through a closure so you can push into components
        // and return something like components.join(separator)
     }
}

您可能应该检查一个元素，以免输入空值。

编辑-有关闭包的更多信息
这是基本问题：假设您有返回如下功能的函数：

function makelist(seperator){
   return function(element){
      let components = []
      components.push(element)
      return components
   }
 }
 
// now use it
// it returns a function
let myFun = makelist(",")

// but every time you run it, it makes a new components
console.log(myFun("a"))  // ["a"]
console.log(myFun("b"))  // ["b"]
// etc.

这不好，因为您希望在每次调用该函数时都将其插入 same 数组。您可以通过使函数访问全局变量来解决此问题：

var GloablComponents = []

function makelist(seperator){
   return function(element){
      GloablComponents.push(element)
      return GloablComponents
   }
 }
 
// now use it
// it returns a function
let myFun = makelist(",")

// Now every time you use it, it pushes to the same array:
console.log(myFun("a"))  // ["a"]
console.log(myFun("b"))  // ["a", "b"]
// etc.

// But there's a problem:
// You want to make independent functions.
// If you make another, it pushes to myFun list as well:

let newFun = makelist(",")
console.log(newFun("C"))  // ["a", "b", "C"] // not what you want

所以这不好，而且依赖于全局变量也不是一个好习惯，因为它们很难跟踪。

关闭
每个函数都会创建自己的作用域，因此，如果您创建一个带有变量的函数，然后在其中创建另一个函数，则内部函数将看到该变量，因为它可以访问外部函数的范围：

function makelist(seperator){
       let aLocalComponent = []         // <------ this out scope
       return function(element){        //          |
          aLocalComponent.push(element) // <-- THIS is referencing
          return aLocalComponent
       }
     }
     
// now use it
// it returns a function
let myFun = makelist(",")

// Now every time you use it, it pushes to the same array
// but it's not a global array, it's the array from
// makelist's scope. That's a closure
console.log(myFun("a"))  // ["a"]
console.log(myFun("b"))  // ["a", "b"]

// Now when make a new function, makelist makes another independent 
// scope. And the new function returned has access to it and its aLocalComponent

let mySecondFun = makelist(",")
console.log(mySecondFun("Z"))  // ["z"]

//At the sametime the old function still accesses the old localcomponentarray:
console.log(myFun("c"))     // only a, b, c

您可以使用相同的想法来确保返回的函数具有相同的分隔符。

Answer 2

function sepfnc(spchar){
    this.spchar = spchar;

    this.join = (a,b)=>{
        return a + this.spchar + b
     }

}


var t = new sepfnc("*");


var c =   t.join("a","b")

alert(c)

更好的方法是像

这样将值作为数组传递

var inputArr = ["a","b"]

functionname("*" , inputArr )

然后加入他们

如果要使用类似的内容，则必须将 char 值存储为函数中的对象，并使用new关键字

喜欢

function sepfnc(spchar){
    this.spchar = spchar;

    this.join = (a,b)=>{
        return a + this.spchar + b
     }

}


var t = new sepfnc("*");


var c =   t.join("a","b")

Answer 3

如果我理解...您有一系列指定要素的单词。您希望创建一个字符串，并在它们之间设置一个分隔符。数组将需要具有函数的作用域，因此将需要在函数声明之外进行声明或用作参数。对于是否需要通过第二个函数传递数组，我有些困惑。如果没有，请参见以下示例：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments：

function myConcat(separator) {
     var args = Array.prototype.slice.call(arguments, 1);
     return args.join(separator);
}

接受一系列参数，并使用指定的分隔符将它们分开。这是一个非常优雅的解决方案，似乎可以完成您想要的工作。否则，您将需要声明一个全局变量并使用它来连接数组，因为每次调用该函数都需要访问它。您可以将其作为参数传递，但这意味着上面的函数就足够了。

JavaScript分隔符和结束符

3 个答案: