TypeScript lodash.trimEnd函数代码示例

export const csvToMap = (csv: string): MapResult => {
  let errors = []
  const trimmed = _.trimEnd(csv, '\n')
  const parsedTVS = Papa.parse(trimmed)
  const templateValuesData: string[][] = _.get(parsedTVS, 'data', [[]])

  if (templateValuesData.length === 0) {
    return {values: {}, errors}
  }

  const keys = new Set<string>()
  let values = {}

  for (const arr of templateValuesData) {
    if (arr.length === 2 || (arr.length === 3 && arr[2] === '')) {
      const key = trimAndRemoveQuotes(arr[0])
      const value = trimAndRemoveQuotes(arr[1])

      if (!keys.has(key) && key !== '') {
        values[key] = value
        keys.add(key)
      }
    } else {
      errors = [...errors, arr[0]]
    }
  }

  return {values, errors}
}

export function getSymmetryName({ group, sub }: Symmetry) {
  if ('TOI'.includes(group)) {
    const prefix = sub === 'h' ? 'full' : 'chiral';
    const base = (() => {
      switch (group) {
        case 'T':
          return 'tetrahedral';
        case 'O':
          return 'octahedral';
        case 'I':
          return 'icosahedral';
        default:
          return '';
      }
    })();
    return `${prefix} ${base}`;
  }
  if (group === 'C') {
    if (sub === 's') {
      return 'bilateral';
    }
    if (sub === '2v') {
      return 'biradial';
    }
    const n = parseInt(_.trimEnd(sub, 'v'), 10);
    return polygonPrefixes.get(n) + ' pyramidal';
  }
  if (group === 'D') {
    const last = sub.substr(sub.length - 1);
    if (last === 'h') {
      const n = parseInt(_.trimEnd(sub, 'h'), 10);
      return polygonPrefixes.get(n) + ' prismatic';
    }
    if (last === 'd') {
      const n = parseInt(_.trimEnd(sub, 'd'), 10);
      return polygonPrefixes.get(n) + ' antiprismatic';
    }

    const n = parseInt(sub, 10);
    return polygonPrefixes.get(n) + ' dihedral';
  }
  throw new Error('invalid group');
}

export function getOrder(name: string) {
  const { group, sub } = getSymmetry(name);
  if ('TOI'.includes(group)) {
    const mult = sub === 'h' ? 2 : 1;
    const base = (() => {
      switch (group) {
        case 'T':
          return 12;
        case 'O':
          return 24;
        case 'I':
          return 60;
        default:
          return 0;
      }
    })();
    return base * mult;
  }
  if (group === 'C') {
    if (sub === 's') {
      return 2;
    }
    const n = parseInt(_.trimEnd(sub, 'v'), 10);
    return 2 * n;
  }
  if (group === 'D') {
    const last = sub.substr(sub.length - 1);
    if (last === 'h') {
      const n = parseInt(_.trimEnd(sub, 'h'), 10);
      return 4 * n;
    }
    if (last === 'd') {
      const n = parseInt(_.trimEnd(sub, 'd'), 10);
      return 4 * n;
    }

    const n = parseInt(sub, 10);
    return 2 * n;
  }
  throw new Error('invalid group');
}

export const addDestinationToFluxScript = (
  script: string,
  options: TaskOptions
): string => {
  const {toOrgName, toBucketName} = options

  if (toOrgName && toBucketName) {
    const trimmedScript = _.trimEnd(script)
    const trimmedOrgName = toOrgName.trim()
    const trimmedBucketName = toBucketName.trim()
    return `${trimmedScript}\n  |> to(bucket: "${trimmedBucketName}", org: "${trimmedOrgName}")`
  }

  return script
}

export function getLogger(name: string): Logger {
  if (!options.enabled) {
    return new Proxy({}, { get: () => _.noop }) as Logger;
  }
  const label = _.trimEnd(name, 'Impl');
  if (cache.has(label)) {
    return cache.get(label);
  }
  const childLogger = logger.child({ label });
  const wrappedLogger = {
    debug: (s: string, ...args) => childLogger.debug(util.format(s, ...args)),
    info: (s: string, ...args) => childLogger.info(util.format(s, ...args)),
    warn: (s: string, ...args) => childLogger.warn(util.format(s, ...args)),
    error: (s: string, ...args) => childLogger.error(util.format(s, ...args))
  };
  cache.set(label, wrappedLogger);
  return wrappedLogger;
}

import {trim, trimStart, trimEnd, pad, padStart, padEnd} from "lodash";

const trimStr: string = "     trim        ";
console.log("trimStart()");
console.log("*" + trimStart(trimStr) + "*");
console.log("trimEnd()");
console.log("*" + trimEnd(trimStr) + "*");
console.log("trim()");
console.log("*" + trim(trimStr) + "*");


const padStr: string = "pad";
console.log("padStart()");
console.log(padStart(padStr, 10, "_"));
console.log("padEnd()");
console.log(padEnd(padStr, 10, "_"));
console.log("pad()");
console.log(pad(padStr, 10, "_"));

 public set BaseUrl(value) {
     if (!value) { throw new Error('BaseUrlMissing'); }
     
     //this.baseUrl = value.TrimEnd('/');
     this.baseUrl = _.trimEnd(value, '/');
 }

  public async getFrequency(response, url) {
    const words: any = {};
    if (response.text) {
      for (const t of response.text) {
        this.getFrequencyByText(t, words);
      }
    }

    if (response.links) {
      for (const link of response.links) {
        if (!link.content.text) {
          console.log('content not found for line ', link);
        }

        for (const t of link.content.text) {
          this.getFrequencyByText(t, words);
        }
      }
    }

    const wordsList: any[] = [];

    Object.keys(words).forEach(key => {
      wordsList.push({
        ideogram: key,
        total: words[key],
      });
    });

    const publicationCode = trimEnd(url, '/')
      .split('/')
      .pop();

    for (const word of wordsList) {
      const publicationFrequency = await knex('publication_frequency').where({
        code: publicationCode,
        ideogram: ideogramConverter.convertIdeogramsToUtf16(word.ideogram),
      });

      if (publicationFrequency.length) {
        continue;
      }

      await knex('publication_frequency').insert({
        code: publicationCode,
        ideogram: ideogramConverter.convertIdeogramsToUtf16(word.ideogram),
        total: word.total,
        created_at: new Date(),
      });
    }

    await knex.raw(`UPDATE (
      SELECT ideogram, SUM(total) total
      FROM publication_frequency
      GROUP BY ideogram
    ) a
    JOIN cjk c ON c.ideogram = a.ideogram
    SET c.usage = a.total`);

    return orderBy(wordsList, ['total'], ['desc']);
  }

 public getName (lb: IGceLoadBalancer, application: Application): string {
   const loadBalancerName = [application.name, (lb.stack || ''), (lb.detail || '')].join('-');
   return trimEnd(loadBalancerName, '-');
 }

    /**
     * @param request
     * @returns {Promise<T>}
     */
    send<T>( request: HttpRequest ): Promise<HttpResponse<T>> {

        let requestConfig: RequestInit = {
            cache : "no-cache",
            method: request.getMethod() as any,
        };

        let url: string = request.getPath();

        let timeout = request.getTimeout();

        if ( request.getBodyParams() ) {
            requestConfig.body = request.getBodyParams();
        }

        if ( !isEmpty(request.getHeaderParams()) ) {
            if ( !requestConfig.headers ) {
                requestConfig.headers = {};
            }
            each(request.getHeaderParams(), ( value, name ) => {
                requestConfig.headers[name] = value;
            });
        }

        if ( !isEmpty(request.getQueryParams()) ) {
            url += '?';
            each(request.getQueryParams(), ( param, name ) => {
                if ( isArray(param) ) {
                    param.forEach(value => {
                        url += `${name}[]=${value}&`;
                    })
                } else {
                    url += `${name}=${param}&`;
                }
            });
            url = trimEnd(url, '&');
        }

        return new Promise(( resolve, reject ) => {
            let rejected = false;

            let timeoutInterval: any = setTimeout(
                () => {
                    rejected = true;
                    reject(new HttpResponse(0, 'Application error', request, 'Timeout of ' + timeout + 'ms exceeded for ' + url, {}));
                },
                timeout
            );

            function returnAsJSON( response, request: HttpRequest, callback: Function ) {
                const cloned = response.clone();

                cloned
                    .text()
                    .then(data => {
                        let responseData = data;
                        try {
                            responseData = JSON.parse(data);
                        } catch (error) {
                        }

                        callback(new HttpResponse(response.status, response.statusText, request, responseData, response.headers))
                    });
            }

            fetch(url, requestConfig).then(
                response => {
                    if ( rejected ) {
                        return;
                    }
                    clearTimeout(timeoutInterval);

                    if ( response.status >= 200 && response.status < 300 ) {
                        returnAsJSON(response, request, resolve);
                        return;
                    }

                    returnAsJSON(response, request, reject);
                    return;
                },
                error => {
                    if ( !rejected ) {
                        reject(new HttpResponse(0, 'Fetch error', request, error, {}));
                    }
                }
            );
        });
    }