TypeScript array.forEach函数代码示例

function register(
    counts: Entries,
    value: string,
    wasSeenAsImportedNamspace: boolean
): Entries {

    if (wasSeenAsImportedNamspace) {
        const existing = bk.at(counts, value);
        if (existing === undefined) {
            bk.addOrFail(counts, value, { name: value, count: 1, wasSeenAsImportedNamespace: true }, unableToAddInitialEntry);
        } else {
            existing.wasSeenAsImportedNamespace = true;
            existing.count += 1;
        }
    } else {
        ba.forEach(
            bx.splitAtHumps(value),
            word => {
                const value = word.toLowerCase();
                const existing = bk.at(counts, value);
                if (existing === undefined) {
                    bk.addOrFail(counts, value, { name: value, count: 1, wasSeenAsImportedNamespace: false }, unableToAddInitialEntry);
                } else {
                    existing.count += 1;
                }
            }
        );
    }

    return counts;
}

export function betterBeNoIssues<r>(tried: TriedCompiling, haveCompiled: (compiled: Compiled) => r): r {

    if (bt.isLuck(tried)) {
        return haveCompiled(tried.luck);
    } else {

        const issues = ba.fromList(tried.fuck);
        ba.forEach(issues, issue => {
            console.warn(formatDiagnostic(issue));
        });

        return bb.fail('Stopped due to detected issues.');
    }
}

function run(args: string): void {
    const optionsTried = readOptions(args);
    const { log, dump } = toBeingStandardConsoleLogging(Severity.Info);
    if (bt.isLuck(optionsTried)) {
        const options = optionsTried.luck;
        log(Severity.Info, 'Reading configuration from: ' + options.configFile);
        const configuration = loadConfigs(options.configFile);
        if (bt.isLuck(configuration)) {
            const beingLogging = toBeingStandardConsoleLogging(options.verbosity);
            const beingOpening = toBeingOpening(
                beingLogging,
                toBeingConfiguring(ts.sys.readFile, ts.sys, beingLogging)
            );
            const pivotDirPath = process.cwd(); // TODO: consider allowing a parameter
            const beingTypeScriptFormatting = toBeingTypeScriptFormatting(filePath => toRelativeTo(filePath, pivotDirPath));
            const beingLintingFormatting = toBeingLintingFormatting(beingTypeScriptFormatting);
            const shared = toShared();
            const { lint, dumpDiagnostics, dumpIssues } = toBeingLinting(beingLogging, beingOpening, toRunners, beingTypeScriptFormatting, beingLintingFormatting);
            const output = lint(options.project, shared, configuration.luck);
            if (bf.isFirst(output)) {
                dumpIssues(output.first, options.maxNumberOfIssues);
            } else if (bf.isSecond(output)) {
                dumpDiagnostics(output.second, options.maxNumberOfDiagnostics);
            } else {
                ba.forEach(
                    output.third,
                    line => log(line.severity, line.message)
                );
            }
        } else {
            log(Severity.Error, 'Unable to load the configuration of the rules. ' + configuration.fuck.message);
        }
    } else {
        const problems = optionsTried.fuck;
        log(Severity.Info, 'Unable to start the linter.');
        dump(Severity.Info, problems, bb.same);
    }
}

 function dump<a>(severity: Severity, value: a, format: (value: a) => string[]): void {
     const lines = format(value);
     ba.forEach(lines, line => {
         log(severity, line);
     });
 }