TypeScript promises.readFile方法代码示例

export async function getSpecificPicture(fileName: string, thumb: boolean = false): Promise<Picture> {
  const splitted = fileName.split('.');
  const type = splitted[splitted.length - 1];
  const filePath = thumb ? `${picturePath}/thumb/${fileName}` : `${picturePath}/${fileName}`;

  try {
    return {
      fileName,
      file: await fs.readFile(path.resolve(filePath)),
      type,
    };
  } catch (e) {
    if (!thumb) {
      throw e;
    }
  }

  const image = await resize({
    src: path.resolve(`${picturePath}/${fileName}`),
    dst: path.resolve(`${picturePath}/thumb/${fileName}`),
    width: 400,
  });
  const file = await fs.readFile(path.resolve(image.path));

  return {
    fileName,
    file,
    type,
  };
}

async function prepare_posts() {
  const dir = `${__dirname}/posts/`;
  const folders = await readdir(dir);

  for (const folder of folders) {
    // TODO: Make parallel
    const data = await readFile(`${dir}${folder}/data.json`, "utf8");
    let post_data = JSON.parse(data);

    const post = await readFile(`${dir}${folder}/post.md`, "utf8");
    marked(post, (err, content) => {
      post_data["text"] = content;
      posts[post_data.title.replace(/ /g, "_")] = post_data;
    });
  }
}

// Create a debugging version of our AutoRest abstraction (ideally we'd just
// launch AutoRest and parse the readme.md, but that's also nontrivial to get
// working correctly)
async function getDebugGeneratorContext(swaggerPath : string, outputPath?: string) : Promise<IGeneratorContext> {
    const dir = outputPath || path.dirname(swaggerPath);
    const settings : { [key: string]: any; } = {
        'input-file': swaggerPath,
        'output-folder': dir,
        'clear-output-folder': false,
        'azure-track2-csharp': true
    };
    const ctx = {
        async getSetting(key: string) : Promise<any> { return Promise.resolve(settings[key]); },
        async getInputUris() : Promise<string[]> { return Promise.resolve([swaggerPath]); },
        log(message: string): void { console.log(`INFORMATION: ${message}`); },
        warn(message: string): void { console.error(chalk.yellow(`WARNING: ${message}`)); },
        error(message: string): void { console.error(chalk.red(`ERROR: ${message}`)); },
        verbose(message: string): void { console.log(`VERBOSE: ${message}`); },
        async readFile(filename: string): Promise<string> {
            const data = await fs.promises.readFile(filename);
            return data.toString();
        },
        async writeFile(filename: string, content: string): Promise<void> {
            ctx.verbose(`Emitting file ${filename}`);
            filename = path.join(dir, filename);
            await fs.promises.mkdir(path.dirname(filename), { recursive: true });
            await fs.promises.writeFile(filename, content, 'utf8');
        }
    }
    return ctx;
}

export async function readOggFile(file: string): Promise<ByteStream> {
    const buffer = await fs.readFile(file);
    const arrayBuffer = buffer.buffer;
    const byteStream = new ByteStream();

    byteStream.setData(arrayBuffer);

    return byteStream;
}

async function main() {
  const root = new Root();
  const { resolvePath } = root;
  const numDirectoriesToStrip = 2;
  let initialOrigin: string|null;
  root.resolvePath = (origin, target) => {
    if (!origin) {
      initialOrigin = target;
      for (let i = 0; i <= numDirectoriesToStrip; i++) {
        initialOrigin = path.dirname(initialOrigin);
      }
      return resolvePath(origin, target);
    }
    return path.resolve(initialOrigin!, target);
  };
  const traceProto = await root.load(process.argv[2]);
  const Trace = traceProto.lookupType("Trace");
  const payload = await fs.promises.readFile(process.argv[3]);
  const msg = Trace.decode(payload).toJSON();
  const output = {
    traceEvents: msg.packet
      .filter((packet: any) => !!packet.chromeEvents)
      .map((packet: any) => packet.chromeEvents.traceEvents)
      .map((traceEvents: any) => traceEvents.map((e: any) => {

        const bind_id = (e.flags & (TRACE_EVENT_FLAG_FLOW_IN |
          TRACE_EVENT_FLAG_FLOW_OUT)) ? e.bindId : undefined;
        const scope = (e.flags & TRACE_EVENT_FLAG_HAS_ID) && e.scope ?
            e.scope : undefined;

        return {
          pid: e.processId,
          tid: e.threadId,
          ts: parseIntOrThrow(e.timestamp),
          tts: parseIntOrThrow(e.threadTimestamp),
          ph: String.fromCodePoint(e.phase),
          cat: e.categoryGroupName,
          name: e.name,
          dur: parseIntOrThrow(e.duration),
          tdur: parseIntOrThrow(e.threadDuration),
          bind_id: bind_id,
          flow_in: e.flags & TRACE_EVENT_FLAG_FLOW_IN ? true : undefined,
          flow_out: e.flags & TRACE_EVENT_FLAG_FLOW_OUT ? true : undefined,
          scope: scope,
          id: (e.flags & TRACE_EVENT_FLAG_HAS_ID) ?
              uint64AsHexString(e.id) : undefined,
          args: (e.args || []).reduce((js_args: any, proto_arg: any) => {
            js_args[proto_arg.name] = parseArgValue(proto_arg);
            return js_args;
          }, {})
        };
      }))
      .reduce(flatten, [])
  };
  await fs.promises.writeFile(process.argv[4], JSON.stringify(output, null, 2));
}

export async function getAll() {
  const hash = await getHash();
  const zipPath = path.resolve(picturePath, `${hash}.zip`);

  try {
    return fs.readFile(zipPath);
  } catch (e) {
    return null;
  }
}

        it('should natively handle cpg1200 re-coding', async () => {
            const input = await fs.promises.readFile('test/examples/cpg1200.rtf');
            const result = await process(input, {
                outputMode: 'buffer-default-cpg'
            });

            expect(result.warnings).to.be.an('array').of.length(1);
            expect(result.decodings).to.be.an('array').of.length(2);

            expect(result.asBuffer.toString('utf16le')).to.eql(`Plain text body: ! < > " ' € œ ¤ ´ ¼ ½ 𠜎 𩶘 😀\r\n`);
        });

async function getMostRecentChangelogEntry(): Promise<string> {
    return fs
        .readFile(path.join(__dirname, 'CHANGELOG.md'), { encoding: 'utf-8' })
        .then(contents => {
            const entry = /(^## .*?)\n^## /ms.exec(contents);
            if (!entry || !entry[1]) {
                throw new Error('Error parsing last changelog entry');
            }
            return entry[1];
        })
        .then(entry =>
            entry.replace(/^## (\S+)/, '= $1 =').replace(/^-/gm, '*'),
        );
}

export async function readPng(file: string): Promise<PNG> {
    const data = await fs.readFile(path.resolve(process.cwd(), file));
    return PNG.sync.read(data);
}

 return p.then(() => fs.readFile(zipPath));