0

我希望能够通过调用类似的东西来填充数组。

necessaryLevel('a','b').necessaryLevel2('name',[X,Y,Z])

以下作为一种可能性，

necessaryLevel('a','b').necessaryLevel2('name',[X,Y,Z]).option(5)

我还需要 .option() 只能从 requiredLevel2 访问，也就是说，在代码的上下文中它应该是不可能编写的，

necessaryLevel('a','b').option(5)

我对javascript相当陌生，并且刚刚开始学习对象和继承。这里也嵌套了正确的术语吗？

任何指针（没有双关语）？

例子：

tag('a','nameVal').value('function_name',[funarg1,funarg2])

输出：

['a','nameVal','function_name',[funarg1,funarg2]]

如果添加 .option 我可能会得到类似的东西

tag('a','nameVal').value('function_name',[funarg1,funarg2]).option(2)

输出：

['a','nameVal','function_name1',[funarg11,funarg21],'function_name2',[funarg12,funarg22]]

编辑：

玩了一下我有这个（未完成）：

function foo(x){
     return {
          bar:function(y){return [x,y] };
      }
 }

 > foo(9.9).bar('la')
 [ 9.9, 'la' ]

我遇到的问题是添加了一个选项函数，以便我可以重复进入 bar() 的内容，例如：

 > foo(9.9).bar('la').option(4)
 [ 9.9, 'la', 'la', 'la', 'la' ]

并且仍然可以灵活地输入 foo(9.9).bar('la')

4

1 回答 1

1

这里有一些东西可以帮助你开始：

例子

var tag = ( function ( hier ) {

  var array = [];

  var calls = [];


  var repeater = function () {

    return function ( times ) {

      while ( calls.length < times ) {

        hier[1].apply( this, calls.slice( -1 )[0] );

      }
      // for


      return array;

    };

  };


  var adder = function ( child_name, child, repeat ) {

    return function () {

      var args = Array.prototype.slice.call( arguments, 0 );

      var orig_args = [].concat( args );

      if ( repeat ) {

        args[0] += calls.length + 1;

        calls.push( orig_args );

      }


      array = array.concat( args );


      var return_val = [].concat( array );


      if ( child_name !== undefined ) {

        return_val[ child_name ] = child;

      }


      return return_val;

    };

  };


  var last_child, args;

  hier.reverse().forEach( function ( child, index, hier ) {

    var method = index ? adder : repeater;

    args = last_child || [];

    if ( index === 1 ) {

      args.push( true );

    }


    hier[ index ] = method.apply( this, args );

    last_child = [ child, hier[ index ] ];

  } );


  return hier.pop();

} )( [ 'tag', 'value', 'option' ] );

在这个版本中，数组本身被返回，但如果你不想覆盖原生属性或方法Array，你必须小心命名你的属性（例如value，option）。

JS对象模型

这里也嵌套了正确的术语吗？

有点儿。在 JS 中，函数是第一类对象，这意味着您可以将它们传递给函数、返回它们、将它们分配给对象的属性等。您要求有一个函数tag返回具有value属性的对象，这是一个函数，它返回一个具有option属性的对象，该属性是一个函数。

如果您只有嵌套对象，则层次结构将如下所示。用于实例化新的通用对象的{...}对象字面量语法，用于代替 JavaScript 中的哈希/映射/字典，并且是无序的。

var tag = {

  value : {

    option : {}

  }

};

因此，例如，您可以访问option：

tag.value.option

您要求一个函数层次结构，每个函数都返回一个具有函数作为属性的对象。因此，在这种情况下，要到达option，您必须这样做：

tag().value().option

在这种情况下，option是一个函数，而不是一个通用对象。

JS函数表达式

当你var a = (function(heir){...})(['a','b','c'])用 parathesis 做的时候它叫什么？

它的一个名称是“立即调用函数表达式 (IIFE)”（见下文）。

下面是一个函数表达式。它创建一个函数对象，您可以将其传递给函数、保存在变量或对象属性中等。

function ( hier ) {...}

您还可以就地执行函数表达式而不将其分配给任何内容：

( function ( hier ) {...} )( ['a','b','c'] )

执行函数表达式。如果需要，您当然可以分配返回值：

var whatever = ( function ( hier ) {...} )( ['a','b','c'] );

函数表达式周围的括号有几个原因。

  1. JavaScript 中的函数语句和函数表达式之间的区别可能很微妙。要像这样就地调用函数，它必须是一个表达式，而括号是确保它是的一种方式。以下是其他人的例子：

    使用运算符为其添加前缀：

    +function ( hier ) {...}( ['a','b','c'] )

    将其放在作业的右侧：

    var whatever = function ( hier ) {...}( ['a','b','c'] );

  2. 即使确定它将被评估为表达式，就像在上一个示例中一样，有些人认为无论如何使用括号是一个很好的约定，以使函数的返回值而不是函数本身更加明显，是表达式的值（在这种情况下是分配给变量的值）。

关于这个主题有一篇很好的文章： Ben Alman 的Immediately-Invoked Function Expression (IIFE)，他建议用这个名称来调用这个构造 (IIFE)。

于 2012-05-03T19:57:04.627 回答