TypeScript lodash.bind函数代码示例

  this.query = function(options) {
    var start = getPrometheusTime(options.range.from, false);
    var end = getPrometheusTime(options.range.to, true);

    var queries = [];
    options = _.clone(options);
    _.each(options.targets, _.bind(function(target) {
      if (!target.expr || target.hide) {
        return;
      }

      var query: any = {};
      query.expr = templateSrv.replace(target.expr, options.scopedVars);

      var interval = target.interval || options.interval;
      var intervalFactor = target.intervalFactor || 1;
      target.step = query.step = this.calculateInterval(interval, intervalFactor);
      var range = Math.ceil(end - start);
      // Prometheus drop query if range/step > 11000
      // calibrate step if it is too big
      if (query.step !== 0 && range / query.step > 11000) {
        target.step = query.step = Math.ceil(range / 11000);
      }

      queries.push(query);
    }, this));

    // No valid targets, return the empty result to save a round trip.
    if (_.isEmpty(queries)) {
      var d = $q.defer();
      d.resolve({ data: [] });
      return d.promise;
    }

    var allQueryPromise = _.map(queries, _.bind(function(query) {
      return this.performTimeSeriesQuery(query, start, end);
    }, this));

    var self = this;
    return $q.all(allQueryPromise)
    .then(function(allResponse) {
      var result = [];

      _.each(allResponse, function(response, index) {
        if (response.status === 'error') {
          self.lastErrors.query = response.error;
          throw response.error;
        }
        delete self.lastErrors.query;

        _.each(response.data.data.result, function(metricData) {
          result.push(self.transformMetricData(metricData, options.targets[index], start, end));
        });
      });

      return { data: result };
    });
  };

 _initExplorer(coin, network, explorer) {
   explorer.initSocket({
     onTx: _.bind(this._handleThirdPartyBroadcasts, this, coin, network),
     onBlock: _.bind(this._handleNewBlock, this, coin, network),
     onIncomingPayments: _.bind(
       this._handleIncomingPayments,
       this,
       coin,
       network
     )
   });
 }

            controller: function($scope, YleinenData, $rootScope, Utils, CloneHelper, OsanMuokkausHelper) {
                $scope.editables = $scope.model;
                $scope.valitseKieli = _.bind(YleinenData.valitseKieli, YleinenData);
                $scope.isEditing = false;

                function getOppiaineenVuosiluokkakokonaisuus() {
                    var ovlk = OsanMuokkausHelper.getOppiaineenVuosiluokkakokonaisuus();
                    ovlk.sisaltoalueinfo = ovlk.sisaltoalueinfo || {
                        otsikko: {},
                        teksti: {}
                    };
                    $scope.ovlk = ovlk;
                }
                getOppiaineenVuosiluokkakokonaisuus();

                var cloner = CloneHelper.init(["nimi", "kuvaus"]);

                $scope.edit = function(alue) {
                    alue.$editing = true;
                    $scope.isEditing = true;
                    cloner.clone(alue);
                };
                $scope.remove = function(alue) {
                    var index = _.findIndex($scope.editables, function(item) {
                        return item === alue;
                    });
                    if (index > -1) {
                        $scope.editables.splice(index, 1);
                    }
                };
                $scope.cancel = function(alue) {
                    alue.$editing = false;
                    $scope.isEditing = false;
                    if (alue.$new) {
                        $scope.remove(alue);
                    } else {
                        cloner.restore(alue);
                    }
                };
                $scope.ok = function(alue) {
                    $rootScope.$broadcast("notifyCKEditor");
                    if (!$scope.hasTitle(alue)) {
                        return;
                    }
                    alue.$editing = false;
                    $scope.isEditing = false;
                };
                $scope.add = function() {
                    $scope.isEditing = true;
                    $scope.editables.push({
                        $editing: true,
                        $new: true,
                        nimi: {},
                        kuvaus: {}
                    });
                };
                $scope.hasTitle = function(alue) {
                    return Utils.hasLocalizedText(alue.nimi);
                };
            }

    .controller("OsanmuokkausTekstikappaleController", function(
        $scope,
        OsanMuokkausHelper,
        $rootScope,
        YleinenData,
        $state,
        $stateParams
    ) {
        $scope.valitseKieli = _.bind(YleinenData.valitseKieli, YleinenData);
        $scope.getTitle = function() {
            return OsanMuokkausHelper.isVuosiluokkakokonaisuudenOsa()
                ? "muokkaus-vuosiluokkakokonaisuuden-osa"
                : $scope.model.$isNew ? "luonti-tekstikappale" : "muokkaus-tekstikappale";
        };
        // Odota tekstikenttien alustus ja päivitä editointipalkin sijainti
        var received = 0;
        $scope.$on("ckEditorInstanceReady", function() {
            if (++received === 2) {
                $rootScope.$broadcast("editointikontrollitRefresh");
            }
        });

        $scope.edit = function() {
            OsanMuokkausHelper.setup($scope.model);
            $state.go("root.perusteprojekti.suoritustapa.muokkaus", $stateParams);
        };
    })

 (done) => {
   this.messageBroker =
     opts.messageBroker || new MessageBroker(opts.messageBrokerOpts);
   this.messageBroker.onMessage(
     _.bind(this._sendPushNotifications, this)
   );
   done();
 }

export function observeCallback<T>(method: (callback: (item: T) => void) => IDisposable, thisContext: any) {
    method = _.bind(method, thisContext);
    return createObservable<T>(observer => {
        const disposable = method((item) => {
            observer.next(item);
        });

        return () => disposable.dispose();
    });
}

        $q.all([modelPromise, vuosiluokatPromise]).then(function(data) {
            // Add addable items to menu
            $scope.vuosiluokkakokonaisuudet = data[1];
            $scope.vuosiluokkakokonaisuudet = _.sortBy($scope.vuosiluokkakokonaisuudet, VlkUtils.orderFn);
            if (_.size($scope.vuosiluokkakokonaisuudet) > 0) {
                $scope.data.options.fields.push({ divider: true, order: 99 });
            }
            var menuItems = [];
            _.each($scope.vuosiluokkakokonaisuudet, function(item) {
                menuItems.push({
                    path: "vuosiluokkakokonaisuudet",
                    localeKey: item.nimi,
                    id: item.id,
                    empty: function() {
                        var vlk = {
                            _vuosiluokkaKokonaisuus: item.id,
                            sisaltoAlueet: [],
                            tavoitteet: []
                        };
                        _.each(["tehtava", "tyotavat", "ohjaus", "arviointi"], function(osio) {
                            vlk[osio] = { otsikko: getTitle(osio), teksti: {} };
                        });
                        return vlk;
                    },
                    order: 10,
                    visibleFn: function() {
                        updateChosen();
                        return _.indexOf($scope.chosenVuosiluokat, item.id) > -1;
                    },
                    remove: function() {
                        var index = _.findIndex($scope.editableModel.vuosiluokkakokonaisuudet, function(vlk: any) {
                            return parseInt(vlk._vuosiluokkaKokonaisuus, 10) === item.id;
                        });
                        $scope.editableModel.vuosiluokkakokonaisuudet.splice(index, 1);
                    }
                });
            });
            _(menuItems)
                .each(function(item, index) {
                    item.order += index;
                })
                .value();
            $scope.data.options.fields = menuItems.concat($scope.data.options.fields);

            // Jos tätä ei ole tabit vaihtelee satunnaisesti poistoilla ja lisäyksillä
            var valitseTabi = _.once(_.bind($scope.chooseTab, {}, $scope.activeTab, true));
            $scope.$watch(
                "editableModel.vuosiluokkakokonaisuudet",
                function() {
                    mapVuosiluokat();
                    valitseTabi();
                },
                true
            );
        });

        it('match function object', () => {
            var obj = {
                value: 10,
                // Note, this has to be a 'function' not 'arrow function' as otherwise 'this' is set incorrectly.
                add: function(n) {
                    return this.value + n;
                }
            };

            let result = _.map([1,2,3], _.bind(obj.add, obj));
            expect(result).toEqual([11,12,13]);
        });

        controller: (
            $scope,
            $q,
            $state,
            $stateParams,
            laajaalaiset,
            laajaalainen,
            Editointikontrollit,
            Notifikaatiot,
            YleinenData,
            ProjektinMurupolkuService,
            vaiheet,
            vaihe,
            isOsaaminen,
            isVaihe,
            isNew,
            AIPEService,
            versiot
        ) => {
            $scope.valitseKieli = _.bind(YleinenData.valitseKieli, YleinenData);
            $scope.isNew = isNew;
            $scope.osanTyyppi = $stateParams.osanTyyppi;
            $scope.versiot = {};
            $scope.$state = $state;
            $scope.aipeService = AIPEService;

            if (isOsaaminen) {
                $scope.isOsaaminen = () => $state.is("root.perusteprojekti.suoritustapa.aipeosaalue");
                $scope.dataObject = laajaalainen;
            } else if (isVaihe) {
                $scope.isVaihe = () => $state.is("root.perusteprojekti.suoritustapa.aipeosaalue");
                $scope.dataObject = vaihe;
                $scope.versiot = versiot;
            }

            $scope.edit = () => {
                Editointikontrollit.startEditing();
            };

            const labels = _.invert(AIPEService.LABELS);
            ProjektinMurupolkuService.set("osanTyyppi", $stateParams.osanTyyppi, labels[$stateParams.osanTyyppi]);
            ProjektinMurupolkuService.set("osanId", $stateParams.osanId, $scope.dataObject.nimi);
        },

    .controller("MuokattavaOsioController", function(
        $scope,
        YleinenData,
        Utils,
        $state,
        OsanMuokkausHelper,
        $stateParams,
        $log
    ) {
        $scope.valitseKieli = _.bind(YleinenData.valitseKieli, YleinenData);
        $scope.hasContent = false;
        $scope.poistoCb = $scope.poistoCb || angular.noop;

        function update() {
            $scope.realModel = $scope.path ? $scope.model[$scope.path] : $scope.model;
            $scope.hasContent =
                _.isArray($scope.realModel) ||
                ($scope.realModel && _.has($scope.realModel, "otsikko")) ||
                $scope.type === "tavoitteet";
            if (_.isArray($scope.model[$scope.path]) && _.isEmpty($scope.model[$scope.path])) {
                $scope.realModel.$isCollapsed = true;
            }
        }
        update();
        $scope.$watch("model", update, true);

        $scope.edit = function() {
            OsanMuokkausHelper.setup($scope.model, $scope.path, $scope.oppiaine, function() {
                $state.go("root.perusteprojekti.suoritustapa.muokkaus", {
                    suoritustapa: $stateParams.suoritustapa,
                    osanTyyppi: $scope.type,
                    osanId: $scope.realModel.id
                });
            });
        };

        $scope.poista = function() {
            $scope.poistoCb($scope.path);
        };
    });