小编shm*_*uli的帖子

Kyle Simpson的"OLOO(链接到其他对象的对象)模式"与原型设计模式有何不同？除了通过专门指示"链接"(原型的行为)的东西创造它并澄清这里没有"复制"(类的行为),他的模式究竟引入了什么？

以下是Kyle在他的书"你不懂JS:这个和对象原型"中的模式的例子:

var Foo = {
    init: function(who) {
        this.me = who;
    },
    identify: function() {
        return "I am " + this.me;
    }
};

var Bar = Object.create(Foo);

Bar.speak = function() {
    alert("Hello, " + this.identify() + ".");
};

var b1 = Object.create(Bar);
b1.init("b1");
var b2 = Object.create(Bar);
b2.init("b2");

b1.speak(); // alerts: "Hello, I am b1."
b2.speak(); // alerts: "Hello, I am b2."

为什么这两个实现的行为不同？在评估他们的原型时,究竟是什么让他们与众不同？

使用指定的原型创建对象:

   function Foo() {}

   // creates an object with a specified prototype
   var bar = Object.create(Foo);

   console.log(Object.getPrototypeOf(bar)); // returns: function Foo(){}
   console.log(Foo.isPrototypeOf(bar)); // returns: true

使用构造方法创建对象:

   function Foo() {}

   // creates an object with the constructor method    
   var bar = new Foo();

   console.log(Object.getPrototypeOf(bar)); // returns: Foo {}
   console.log(Foo.isPrototypeOf(bar)); // returns: false

另外,为什么第二个实现返回Foo {}和false？

我已经为AngularJS编写了这个自定义过滤器,但是当它运行时,我得到了无限的摘要循环错误.为什么会发生这种情况,我该如何纠正？

angular.module("app", []).
filter('department', function(filterFilter) {
  return function(items, args) {
    var productMatches;
    var output = [];
    var count = 0;

    if (args.selectedDepartment.Id !== undefined && args.option) {
      for (let i = 0; i < items.length; i++) {

        productMatches = items[i].products.filter(function(el) {
          return el.Order__r.Department__r.Id === args.selectedDepartment.Id;
        });

        if (productMatches.length !== 0) {
          output[count] = {};
          output[count].products = productMatches;
          output[count].firstProduct = items[i].firstProduct;
          count++;
        }

      }
    }
    return output;
  };
}).

这是相关的HTML:

<tr class='destination' ng-repeat-start='pickupAccount in pickupAccounts | department : {"selectedDepartment": selectedDepartment, "option": …

我正在阅读道格拉斯·克罗克福德的"Javascript,The Good Parts",并且难以理解所有铁路图的使用.他也没有详细说明这一点.他只是说了以下内容(第21页):

解释这些图表的规则很简单:

• 从左边缘开始,沿着轨道向右边缘移动.
• 当你走的时候,你会遇到椭圆形的文字,以及矩形的规则或描述.
• 通过跟踪轨道可以制作的任何序列都是合法的.
• 跟踪轨道无法制作的任何序列都是不合法的.
• 每端有一个条形的铁路图允许在任何一对标记之间插入空格.两端有两根钢筋的铁路图没有.

我知道这本书被认为是对任何真正认真对待Javascript的人的基本阅读,我非常想了解他正在解决的概念.但有些事情并不是点击整个铁路图的事情.

谁能解释他对铁路图的使用？例子很棒.

我需要在 React Native 上缩进段落的第一行。但是公共 csstext-indent属性 ( textIndent)的使用与 React Native 不兼容，伪元素选择器（如:first-line）也不兼容。有没有办法在不将整行包装在<Text>标签中并定义自己的样式的情况下做到这一点？从一个设备的视口到另一个设备的视口，哪些词将出现在段落的第一行有些不确定。

我正在处理一个涉及许多开发人员的大型 Web 项目，我想缩小 Bootstrap3 的包并只保留我们正在使用的内容。基本上，这个想法是在浏览器中加载页面时减少任何额外的开销。

所以我有两种方法可以做到这一点：

我也可以...

a.) 从库中删除任何额外的部分，创建一个新的构建，然后将其加载到我们的项目中。

例如：

<!-- Custom build of a slimmed down Bootstrap -->
<script src="/bootstrap/3.0.3/js/bootstrap.min.js"></script>

或者...

b.) 将整个 Bootstrap3 模块化，将每个组件分离到自己的文件中，并将整个构建写入 html，同时注释掉我们不需要的东西。

例如：

<!-- All Bootstrap components-->
<script src="/bootstrap/3.0.3/js/glyphicons_bootstrap.min.js"></script>
<script src="/bootstrap/3.0.3/js/buttongroups.min.js"></script>
<script src="/bootstrap/3.0.3/js/inputgroups_bootstrap.min.js"></script>
<!-- <script src="/bootstrap/3.0.3/js/navs_bootstrap.min.js"></script> DON'T NEED THIS -->
<script src="/bootstrap/3.0.3/js/navbars_bootstrap.min.js"></script>
<!-- <script src="/bootstrap/3.0.3/js/breadcrumbs_bootstrap.min.js"></script> DON'T NEED THIS -->
<script src="/bootstrap/3.0.3/js/pagination_bootstrap.min.js"></script>

等等...

使用第二个选项的优势在于，它可以让其他开发人员更好地控制我们加载到项目中的引导组件，而无需再次重建它。如果将来在任何情况下他们需要加载一些新的 Bootstrap 组件，他们只需取消对该行代码的注释即可。这将使其他开发人员使用起来更加灵活，并且不会限制他们使用 Bootstrap 在整个项目中进一步开发。

然而，对此有什么想法？将更多文件拉入项目（而不是拉入一个大文件）会增加加载时的开销吗？这是否违反“良好/最佳实践”？

这两个原型继承实现之间有什么区别,并且考虑到我们正在使用2个不同的"原型"(仅在函数和内部原型上的原型属性),以及这些实现在原型链查找中有何不同？另外,第一个实现(使用prototype属性)是否依赖于我们对new运算符的使用？

分配给函数的prototype属性并使用new运算符:

function foo() {}

foo.prototype.output = function(){
   console.log('inherits from Function.prototype property');
};

bar = new foo();
bar.output();

将函数存储在对象文字中并使用该Object.create()方法:

var foo = {
  output: function(){
    console.log('inherits from the internal prototype');
  }
};

var bar = Object.create(foo);
bar.output();

我正在测试 James Shore 的Object Playground，我看到所有方法都继承自 Function.prototype，包括全局 Object.prototype 上的方法。这是如何运作的？是不是有点圆？我的意思是...不是 Object.prototype 固有的 Function.prototype “本身”吗？那么 Object 是如何从 Function.prototype 中继承任何东西的呢？函数不只是对象的子类型吗？无论如何，对象本身不应该包含这些行为吗？为什么需要继承？

为什么array_reduce()添加和乘法时该方法的工作方式不同？当我在下面添加数组值时,代码会产生预期的结果:15.但是当我乘以时,它返回:0.相同的代码......唯一的区别是+标志是为*标志切换的.

  function sum($arr){
        print_r(array_reduce($arr, function($a, $b){return $a + $b;}));
    }

    function multiply($arr){
        print_r(array_reduce($arr, function($a, $b){return $a * $b;}));
    }

    sum(array(1, 2, 3, 4, 5)); // 15
    multiply(array(1, 2, 3, 4, 5)); // 0

有没有办法在observable开始执行时附加一个处理程序(有人在其上调用subscribe)？

喜欢角度:

    this.http.post('someUrl', resource).pipe(
       catchError(),
       finalize((() => this.hideLoader()),
       **executing(() => this.showLoader()) <------**
    )