TypeScript lodash.without函数代码示例

function curryParams(
    baseName: string,
    sourceOverloadId: number,
    sourceOverload: Overload,
    interfaceIndex: number,
): Interface {
    const params = getInterfaceParams(sourceOverload, interfaceIndex);
    const interfaceTypeParams = getInterfaceTypeParams(sourceOverload, interfaceIndex);

    const prevParams = _.without(sourceOverload.params, ...params);
    const prevTypeParams = getUsedTypeParams(prevParams, sourceOverload.typeParams);
    const typeParams = _.without(sourceOverload.typeParams, ...prevTypeParams);
    // 1st overload takes no parameters and just returns the same interface (effectively a no-op)
    // HACK: omit the parameterless overload because it's not very useful, and it causes the build to run out of memory
    // This assumes params.length > 0, which is true because curryParams is only called when params.length >= 2.
    /*const overloads: Overload[] = [{
        typeParams: [],
        params: [],
        returnType: getInterfaceName(baseName, sourceOverloadId, interfaceIndex, interfaceTypeParams),
        jsdoc: sourceOverload.jsdoc,
    }];*/
    const overloads: Overload[] = [];
    const lastOverload = (1 << params.length) - 1;
    for (let i = 1; i <= lastOverload; ++i) {
        // xxxx i = number of parameters used by this overload
        // const totalCombinations = nCk(params.length, i);
        // i = binary representation of which parameters are used for this overload (reversed), e.g.
        //   1 = 0001 -> 1000 = 1st parameter
        //   6 = 1010 -> 0101 = 2nd and 4th parameters
        const currentParams = params.map((p, j) => (i & (1 << j)) ? p : `${getParamName(p)}: __`);
        while (currentParams.length > 0 && _.last(currentParams)!.endsWith("__"))
            currentParams.pop(); // There's no point in passing a placeholder as the last parameter, so don't allow it.

        const usedTypeParams = i < lastOverload ? getUsedTypeParams(currentParams, typeParams) : typeParams;
        const combinedIndex = combineIndexes(interfaceIndex, i);
        const passTypeParams = getInterfaceTypeParams(sourceOverload, combinedIndex);
        const currentReturnType = i < lastOverload ? getInterfaceName(baseName, sourceOverloadId, combinedIndex, passTypeParams) : sourceOverload.returnType;

        overloads.push({
            typeParams: _.cloneDeep(usedTypeParams),
            params: currentParams,
            returnType: currentReturnType,
            jsdoc: interfaceIndex === 0 ? sourceOverload.jsdoc : "",
        });
    }
    const interfaceDef: Interface = {
        name: getInterfaceName(baseName, sourceOverloadId, interfaceIndex, []),
        typeParams: _.cloneDeep(interfaceTypeParams),
        overloads,
        constants: [],
    };
    // Remove the `extends` constraint from interface type parameters, because sometimes they extend things that aren't passed to the interface.
    for (const typeParam of interfaceDef.typeParams) {
        // 1. retain `extends keyof X` constraints so that TObject[TKey] still works.
        // 2. retain `any[]` constraints so that variadic generics work.
        if (!_.startsWith(typeParam.extends, "keyof ") && typeParam.extends !== "any[]")
            delete typeParam.extends;
    }
    return interfaceDef;
}

  kickMember(member: GuildMember, propagate = true) {

    // check if they're online, remove guildName (basically, call memberLeave)
    const onlinePlayer = GameState.getInstance().getPlayer(member.name);
    if(onlinePlayer && onlinePlayer.guildName !== this.name) return;

    if(onlinePlayer) {
      this.memberLeave(onlinePlayer);

      // check if member is even in guild (ie, could just be an invite)
      const memberInList = _.find(this.members, { name: member.name });
      this.members = _.without(this.members, memberInList);
      this.save(true);

    } else if(propagate) {
      GuildKickRedis(this.name, member.name);
    } else if(!propagate) {

      // if not online, dig into db and unset guildName
      const memberInList = _.find(this.members, { name: member.name });
      this.members = _.without(this.members, memberInList);
      this.$guildDb.removePlayerFromGuild(member.name, this.name);
      this.save(true);
    }

  }

  removeValue(commandClass: number, index) {
    if (this.commandClassExists(commandClass)) {
      const filteredCommandClass = without(this.values[commandClass], index);

      this.values.set(commandClass, filteredCommandClass);
    }
  }

 .add<{ index: number }>("REMOVE_STEP", function (state, action) {
     let seq = state.all[state.current];
     let index = action.payload.index;
     seq.body = _.without(seq.body, seq.body[index]);
     markDirty(state);
     return state;
 })

    return async (dispatch: (action: any) => void, getState: () => GertyState, bundle: Bundle) => {

        const state = getState();

        const isWorkspace = relativePath === state.configuration.workspacePath;

        const repositoryDataPath = isWorkspace
            ? "workspace.hosts"
            : `repositories.${relativePath}.hosts`;

        const hosts = _.get(state.data, repositoryDataPath, []) as Host[];

        const newHosts = _.without(hosts, hosts[index]);

        dispatch({
            type: "set-data-value",
            path: repositoryDataPath,
            value: newHosts,
        } as SetDataValueAction);

        if (isWorkspace) {

            await dispatch(saveWorkspace());
        }
        else {

            await dispatch(saveRepository(relativePath));
        }
    };

 removeTag(tag, evt) {
   this.query.tag = _.without(this.query.tag, tag);
   this.search();
   this.giveSearchFocus = this.giveSearchFocus + 1;
   evt.stopPropagation();
   evt.preventDefault();
 }

  static getMetricFieldKey(segment) {
    const keys = _.keys(segment);

    return _.filter(_.without(keys, 'start', 'end'), key => {
      return _.isObject(segment[key]);
    })[0];
  }

  removeQuery() {
    if (this.panelCtrl.__collapsedQueryCache) {
      delete this.panelCtrl.__collapsedQueryCache[this.target.refId];
    }

    this.panel.targets = _.without(this.panel.targets, this.target);
    this.panelCtrl.refresh();
  }

 public stopInstance(dotEnsime: DotEnsime): void {
     for (const instance of this.instances) {
         if (instance.rootDir === dotEnsime.rootDir) {
             instance.destroy()
             this.instances = _.without(this.instances, instance)
         }
     }
 }

 stopInstance(dotEnsime: DotEnsime) {
   for (let instance of this.instances) {
     if(instance.rootDir == dotEnsime.rootDir) {
       instance.destroy()
       this.instances = _.without(this.instances, instance)
     }
   } 
 }