TypeScript angular.isArray函數代碼示例

        this.settings = function(newSettings?: ISettings<T>) {
            if (ng1.isDefined(newSettings)) {

                // todo: don't modify newSettings object: this introduces unexpected side effects;
                // instead take a copy of newSettings

                if (newSettings.filterOptions){
                    newSettings.filterOptions = ng1.extend({}, _settings.filterOptions, newSettings.filterOptions);
                }
                if (newSettings.groupOptions){
                    newSettings.groupOptions = ng1.extend({}, _settings.groupOptions, newSettings.groupOptions);
                }

                if (ng1.isArray(newSettings.dataset)) {
                    //auto-set the total from passed in dataset
                    newSettings.total = newSettings.dataset.length;
                }

                var originalDataset = _settings.dataset;
                _settings = ng1.extend(_settings, newSettings);

                if (ng1.isArray(newSettings.dataset)) {
                    optimizeFilterDelay();
                }

                // note: using != as want null and undefined to be treated the same
                var hasDatasetChanged = newSettings.hasOwnProperty('dataset') && (newSettings.dataset != originalDataset);
                if (hasDatasetChanged) {
                    if (isCommittedDataset){
                        this.page(1); // reset page as a new dataset has been supplied
                    }
                    isCommittedDataset = false;

                    var fireEvent = function () {
                        ngTableEventsChannel.publishDatasetChanged(self, newSettings.dataset, originalDataset);
                    };

                    if (initialEvents){
                        initialEvents.push(fireEvent);
                    } else {
                        fireEvent();
                    }
                }
                log('ngTable: set settings', _settings);
                return this;
            }
            return _settings;
        };

    angular.forEach(rowLabelsElements, function (rowLabelElement, i) {
      rowLabelElement = jQuery(rowLabelElement)

      let rowModel = data[i]
      let rowText = rowLabelElement.text().trim()
      if (contentNotSupported || rowModel.content === undefined) {
        expect(rowText).to.be.eq(rowModel.name)
      } else {
        let rowHtmlModel = rowModel.content
        rowHtmlModel = rowHtmlModel.replace('{{row.model.name}}', rowModel.name)
        let expectedRowText = rowHtmlModel.replace(/<(?:.|\n)*?>/gm, '').trim() // Strip HTML
        expect(rowText).to.be.eq(expectedRowText)
      }

      if (rowModel.classes) {
        let rowClasses = rowModel.classes
        if (!angular.isArray(rowClasses)) {
          rowClasses = [rowClasses]
        }

        angular.forEach(rowClasses, function (rowClass) {
          expect(rowLabelElement.parents().hasClass(rowClass)).to.be.ok
        })
      }
    })

	/**
	 * Apply locale string in format "...{0}...{1}..." and apply instead of '{n}' params[n]
	 * @param {string} locale text key. This key contains in resources.
	 * @param {strong} defaultValue. Default value if locale resource wasn't found.
	 * @param {Array} params. Additional params.
	 * @returns {string}. Localized text. 
	 */
	localeTextWithParams(key: string, defaultValue: string, params: string[]): string {
		let result = this.localeText(key, defaultValue);
		if (angular.isArray(params))
			params.forEach((param, iParam) =>
				result = result.replaceAll(`{${iParam}}`, param));
		return result;
	}

    it('should be wrapped in an array if array: true', function() {
      const m = $umf.compile('/foo?param1', { params: { param1: { array: true } } });

      // empty array [] is treated like "undefined"
      expect(m.format({ param1: undefined })).toBe('/foo');
      expect(m.format({ param1: [] })).toBe('/foo');
      expect(m.format({ param1: '' })).toBe('/foo');
      expect(m.format({ param1: '1' })).toBe('/foo?param1=1');
      expect(m.format({ param1: ['1'] })).toBe('/foo?param1=1');
      expect(m.format({ param1: ['1', '2'] })).toBe('/foo?param1=1&param1=2');

      expect(m.exec('/foo')).toEqual({ param1: undefined });
      expect(m.exec('/foo', {})).toEqual({ param1: undefined });
      expect(m.exec('/foo', { param1: '' })).toEqual({ param1: undefined });
      expect(m.exec('/foo', { param1: '1' })).toEqual({ param1: ['1'] });
      expect(m.exec('/foo', { param1: ['1', '2'] })).toEqual({ param1: ['1', '2'] });

      $url.url('/foo');
      expect(m.exec($url.path(), $url.search())).toEqual({ param1: undefined });
      $url.url('/foo?param1=');
      expect(m.exec($url.path(), $url.search())).toEqual({ param1: undefined });
      $url.url('/foo?param1=bar');
      expect(m.exec($url.path(), $url.search())).toEqual({ param1: ['bar'] });
      $url.url('/foo?param1=bar&param1=baz');
      if (angular.isArray($url.search()))
        // conditional for angular 1.0.8
        expect(m.exec($url.path(), $url.search())).toEqual({ param1: ['bar', 'baz'] });

      expect(m.format({})).toBe('/foo');
      expect(m.format({ param1: undefined })).toBe('/foo');
      expect(m.format({ param1: '' })).toBe('/foo');
      expect(m.format({ param1: 'bar' })).toBe('/foo?param1=bar');
      expect(m.format({ param1: ['bar'] })).toBe('/foo?param1=bar');
      expect(m.format({ param1: ['bar', 'baz'] })).toBe('/foo?param1=bar&param1=baz');
    });

        return function (items: any, filterOn: any) {

            if (filterOn === false) {
                return items;
            }

            if ((filterOn || angular.isUndefined(filterOn)) && angular.isArray(items)) {
                var hashCheck: any = {}, newItems: any[] = [];

                var extractValueToCompare = function (item: any) {
                    if (angular.isObject(item) && angular.isString(filterOn)) {
                        return item[filterOn];
                    } else {
                        return item;
                    }
                };

                angular.forEach(items, (item: any)=> {
                    var valueToCheck, isDuplicate = false;

                    for (var i = 0; i < newItems.length; i++) {
                        if (angular.equals(extractValueToCompare(newItems[i]), extractValueToCompare(item))) {
                            isDuplicate = true;
                            break;
                        }
                    }
                    if (!isDuplicate) {
                        newItems.push(item);
                    }

                });
                items = newItems;
            }
            return items;
        };

export function assignPartialDeep<T extends TPartial, TPartial>(
    destination: T, 
    partial: TPartial,
    optionalPropSelector: (key: string, destination: T) => boolean = () => false,
    customizer: (destValue: any, srcValue: any, key: string) => any = () => undefined
 ) {
    const keys = Object.keys(partial);
    for(const key of keys) {
        let srcVal = partial[key];
        if (srcVal === undefined) {
            if (optionalPropSelector(key, destination)){
                destination[key] = srcVal;
            } else {
                // don't assign undefined to destination
            }
            continue;
        }

        const destVal = destination[key];
        const customVal = customizer(destVal, srcVal, key);
        if (customVal !== undefined){
            destination[key] = customVal;
        } else if (ng1.isArray(srcVal)) {
            destination[key] = [...srcVal];
        } else if (!ng1.isObject(srcVal)) {
            destination[key] = srcVal;
        } else {
            destination[key] = assignPartialDeep(destVal, srcVal);
        }
    }
    return destination;
}

 const removePrototype = (srcVal: any, objVal: any) => {
     if (ng1.isObject(objVal) && !ng1.isArray(objVal)) {
         return _.toPlainObject(objVal);
     } else {
         return objVal;
     }
 };

			constraintFilters.forEach(constraintFilter => {
				const constraintFilterOperatorValue = constraintFilter && constraintFilter.operator ? constraintFilter.operator.value : '';

				if (constraintFilter.field !== null && angular.isObject(constraintFilter.operator)
					&& constraintFilterOperatorValue !== '' && angular.isArray(constraintFilter.values)
					&& constraintFilter.values.length > 0) {
					const constraintParamPart = {};
					constraintParamPart[`fc${counter}`] = constraintFilter.field.sysname;
					constraintParamPart[`fo${counter}`] = constraintFilterOperatorValue;
					const constraintOperatorType = this.getFieldFilterOperatorValueType(constraintFilter.operator);
					if (constraintOperatorType === 'twoValues') {
						constraintParamPart[`fvl${counter}`] = constraintFilter.values[0];
						constraintParamPart[`fvr${counter}`] = constraintFilter.values[1];
					} else if (constraintOperatorType === 'twoDates') {
						constraintParamPart[`fvl${counter}`] = moment(constraintFilter.values[0]).format(this.$izendaSettingsService.getDateFormat().shortDate);
						constraintParamPart[`fvr${counter}`] = moment(constraintFilter.values[1]).format(this.$izendaSettingsService.getDateFormat().shortDate);
					} else if (constraintOperatorType === 'oneDate') {
						constraintParamPart[`fvl${counter}`] = moment(constraintFilter.values[0]).format(this.$izendaSettingsService.getDateFormat().shortDate);
					} else if (constraintOperatorType === 'field') {
						const val = angular.isObject(constraintFilter.values[0])
							? constraintFilter.values[0].sysname
							: '';
						constraintParamPart[`fvl${counter}`] = val;
					} else {
						constraintParamPart[`fvl${counter}`] = constraintFilter.values.join(',');
					}

					angular.extend(queryParams, constraintParamPart);
					counter++;
				}
			});

angular.module("eperusteApp").directive("oikeustarkastelu", function(PerusteprojektiOikeudetService) {
    return {
        restrict: "A",
        link(scope, element: any, attrs: any) {
            var oikeudet = scope.$eval(attrs.oikeustarkastelu);
            if (!angular.isArray(oikeudet)) {
                oikeudet = [oikeudet];
            }
            if (
                !_.any(oikeudet, function(o: any) {
                    return PerusteprojektiOikeudetService.onkoOikeudet(o.target, o.permission);
                })
            ) {
                // Ei toimi jos ng-disabled myös käytössä
                /*
                if (element.prop("tagName") === "BUTTON") {
                    element.prop("disabled", true);
                } else {
                    element.hide();
                }
                */
                element.hide();
            }
        }
    };
});

        this.appendTransform = function (defaults: any, transform: any) {

            // We can't guarantee that the default transformation is an array
            defaults = angular.isArray(defaults) ? defaults : [defaults];

            // Append the new transformation to the defaults
            return defaults.concat(transform);
        }