検索
ホームページウェブフロントエンドjsチュートリアルNode.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

Node.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

青灯夜游
青灯夜游
Dec 22, 2021 pm 07:23 PM
node.jsストリーム

この記事では、Node における Stream を理解し、Readable Stream、Writable Stream、Duplex Stream、Conversion Stream を実現するための Stream 導入方法を紹介します。 。 ヘルプ！

Node.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

ストリームの紹介

このような要件があると仮定すると、あるファイルの内容を別のファイルにコピーする必要があります。次のコードを書き込みます。

const fs = require('fs');
const path = require('path');

const copy = (source, target) => {
    fs.readFile(path.resolve(source), (err, data) => {
        if(err) {
            throw new Error(err.toString());
            return;
        }
        fs.writeFile(path.resolve(target), data, (err) => {
            if(!err) {
                console.log("复制成功！");
            }
        })
    })
}

上記のコードは非常に単純です。つまり、最初に source ファイルの内容を読み取り、次にその内容を target## に書き込みます。 ＃ ファイル 。その特徴は、source の すべての内容 を読み取って、その内容を target に書き込む必要があることです。

これには欠点があります。大きなファイルを読み取る場合、最初にファイルのすべての内容がメモリに読み込まれるため、メモリが不足する可能性があります。また、大きなファイルをメモリに読み込むのにも時間がかかります。一度に実行すると時間がかかり、ユーザーは行き詰まりを感じる可能性があります。

もう 1 つの解決策は、読み取りと書き込みを同時に行い、ファイルの内容の一部を読み取り、その内容を新しいファイルに書き込むことです。この方法では、メモリ内のデータは内容の一部にすぎません。メモリをあまり占有しません。読み取り中に書き込まれるため、ユーザーは迅速に応答を得ることができ、ユーザー エクスペリエンスが向上します。

インターネット

で、フローを使用する前と後のデータの流れを生き生きと示すアニメーション画像を見つけました

Node.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

Node.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

Node.js

は、特に大きなファイルの処理に使用される Stream API を提供します。水の流れのようにデータを部分ごとに処理するため、このモジュールの名前はストリームと呼ばれます。 

const fs = require('fs');

function copy(source, target) {
    const rs = fs.createReadStream(source);
    const ws = fs.createWriteStream(target);

    rs.on('data', data => {
        ws.write(data);
    });

    rs.on('end', () => {
        ws.end();
    });
}
上記のコードの詳細は後ほど公開します。

#ストリームの分類

ストリームは 4 つのカテゴリに分類できます

Readable: 読み取り可能なストリーム、データ プロバイダー

# Writeable: 書き込み可能なストリーム、データのコンシューマー
  • Duplex: 書き込み可能および読み取り可能なストリーム (二重ストリーム)
  • Transform: これは Duplex の特殊なケースであり、入力用の変換ストリームです。データは処理され、次に出力
  • #読み取り可能なストリームと書き込み可能なストリームが基本です。一般的な読み取り可能なストリームと書き込み可能なストリームは次のとおりです。

読み取り可能なストリーム書き込み可能なストリーム#HTTP リクエストHTTP レスポンス ##fs 読み取りストリームfs 書き込みストリームprocess.stdinprocess.stdout TCP ソケット TCP ソケット##zlib ストリーム##zlib ストリーム#暗号ストリーム
暗号ストリーム
#

Stream 是 EventEmitter 的实例，有自定义的事件。

Readable Stream

可读流有两个模式，暂停模式与流动模式。当我们创建一个流时，如果我们监听了 readable 事件，它就会来到暂停模式，在暂停模式下，它会不断的读取数据到缓冲区，当读取到的数据超过预设的大小时，它由属性 highWaterMark 指定(默认为 64kB)，便会触发 readable 事件，readable 事件的触发有两种情况：

  • 缓存区中的数据达到 highWaterMark 预设的大小
  • 数据源的数据已经被读取完毕
const fs = require('fs');

const rs = fs.createReadStream('a.txt', {
    highWaterMark: 1 // 缓存区最多存储 1 字节
});

rs.on('readable', () => {
    let data;
    while(data=rs.read()) {
        console.log(data.toString());
    }
})

上面的程序设置 highWaterMark 为 1，即每次读取到一个字节便会触发 readable 命令，每次当触发 readable 命令时，我们调用可读流的 read([size]) 方法从缓冲区中读取数据(读取到的数据为 Buffer)，然后打印到控制台。

当我们为可读流绑定 data 事件时，可读流便会切换到流动状态，当位于流动状态时，可读流会自动的从文件中读取内容到缓冲区，当缓冲区中的内容大于设定的 highWaterMark 的大小时，便会触发 data 事件，将缓冲区中的数据传递给 data 事件绑定的函数。以上过程会自动不断进行。当文件中的所有内容都被读取完成时，那么就会触发 end 事件。

const fs = require('fs');

const rs = fs.createReadStream('a.txt', {
    highWaterMark: 2
});

rs.on('data', data => {
    console.log(data.toString());
});

rs.on('end', () => {
    console.log("文件读取完毕！");
});

暂停模式像是手动步枪，而流动模式则像是自动步枪。暂停模式与流动模式也可以相互切换，通过 pause() 可以从流动状态切换到暂停状态，通过 resume() 则可以从暂停模式切换到流动模式。

可读流的一个经典实例就是 http 中的请求对象 req，下面的程序展示了通过监听 req 的 data 事件来读取 HTTP 请求体中的内容

const http = require('http');

const app = http.createServer();

app.on('request', (req, res) => {
    let datas = [];
    req.on('data', data => {
        datas.push(data);
    });

    req.on('end', () => {
        req.body = Buffer.concat(datas);
        // 当读取完 body 中的内容之后，将内容返回给客户端
        res.end(req.body);
    });
})

app.listen(3000, () => {
    console.log("服务启动在 3000 端口... ...");
})

Node.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

Writable Stream

可写流与可读流相似，当我们向可写流写入数据时(通过可写流的 write() 方法写数据)，会直接将数据写入到文件中，如果写入的数据比较慢的话，那就就会将数据写入到缓冲区，当缓冲区中的内容达到 highWaterMark 设定的大小时，write 方法就会返回一个 false，表明不能接受更多的数据了。

当缓冲区中的数据全部被消费完了(写入了文件中或者被别的流消费了)，那么就会触发 drain 事件。

const fs = require('fs');

const ws = fs.createWriteStream('b.txt', {
    highWaterMark: 16 * 1024
});

function writeMillionTimes(writer, data, encoding, callback) {
    let i = 10000;
    
    write();

    function write() {
        // 表示是否可以向可写流中写入数据
        let ok = true;
        while(i-- > 0 && ok) {
            // 当 writer.write() 方法返回  false 表示不可写入数据
            ok = writer.write(data, encoding, i === 0 ? callback : null);
        }

        if(i > 0) {
            // 说明 ok 为 false，即不能向缓冲区中写入内容了
            console.log("drain", i);
            // 监听 drain 事件，当队列消费完毕时继续调用 write() 方法写入
            writer.once('drain', write);
        }
    }
}

writeMillionTimes(ws, 'simple', 'utf-8', () => {
    console.log("end");
})

输出为

drain 7268
drain 4536
drain 1804
end

说明有三次缓冲区中的内容达到了 16KB，可以验算上面的数字之间的差值，在乘以 6(simple 的字节数)，大小大约为 16 * 1024 左右，如

(7268−4536)∗6=16392≈16384=16∗1024(7268 - 4536) * 6 = 16392 \approx 16384 = 16 * 1024

我们还可以调用可写流的 end() 方法，表示将缓存中的内容清空写入文件，并关闭文件，此时会触发 close 事件

const fs = require('fs');

const ws = fs.createWriteStream('b.txt');

ws.write('Hello');
ws.write('World');
ws.end('!');

ws.on('close', () => {
    console.log("close"); // close
})

当调用 end() 方法之后就不能调用 write() 方法了，否则会报错

const fs = require('fs');

const ws = fs.createWriteStream('b.txt');

ws.write('Hello');
ws.write('World');
ws.end('!');

ws.write('write again'); // Error [ERR_STREAM_WRITE_AFTER_END]: write after end

当调用 end() 方法之后，并且数据缓冲区中的数据已经写入之后会触发可写流的 finish 事件

const fs = require('fs');

const ws = fs.createWriteStream('b.txt');

ws.write('Hello');
ws.write('World');
ws.end('!');

ws.on('close', () => {
    console.log("close");
});

ws.on('finish', () => {
    console.log("finish");
});

打印结果是

finish
close

说明 finish 事件会在 close 事件之前被触发。

可写流的经典例子就是 http 模块的响应对象 res，下面的程序演示了当请求到来时，我们读取一个 html 页面返回给客户端

const http = require('http');
const fs = require('fs');

const app = http.createServer();

app.on('request', (req, res) => {
    const rs = fs.createReadStream('index.html');
    
    rs.on('data', data => {
        res.write(data);
    })

    rs.on('end', () => {
        res.end()
    });
});

app.listen(3000, () => {
    console.log("服务启动在 3000 端口 ... ...");
})

Duplex Stream 与 Transform Stream

Duplex，即双工的意思，它既可以接收数据，也可以输出数据，它的输入和输出之间可以没有任何的关系，就像是一个部件内部有两个独立的系统。Duplex 继承了可读流(Readable)，并且拥有可写流(Writable)的所有方法。

Transform Stream 继承了 Duplex Stream，它同样具有可读流与可写流的能力，并且它的输出与输入之间是有关系的，中间做了一次转换。常见的转换流有 zlib，crypto。

出于文章结构的考虑，在这里不详细讲解这两个流，在后文中会实现这两个流，以加深对这两个流的理解。

pipe

我们可以混合使用可读流与可写流来进行文件的复制

const fs = require('fs');

function copy(source, target) {
    const rs = fs.createReadStream(source);
    const ws = fs.createWriteStream(target);

    rs.on('data', data => {
        ws.write(data);
    });

    rs.on('end', () => {
        ws.end();
    });
}

copy('a.txt', 'b.txt');

但是上面的写法却不被建议使用，因为没有考虑到可读流与可写流速度之间的差异，如果可读流输出数据的速度大于可写流写入数据的速度，这个时候就会有数据一直堆压在缓存区，导致占用过高的内存，专业术语叫做积压。

我们需要改善上面的程序，具体做法就是当 write() 方法返回  false 时，我们切换可读流的模式为暂停模式，当可写流触发了 drain 事件时，我们便将可读流的状态切换为流动模式

const fs = require('fs');

function copy(source, target) {
    const rs = fs.createReadStream(source);
    const ws = fs.createWriteStream(target);

    rs.on('data', data => {
        if (!ws.write(data)) {
            rs.pause();
        }
    });

    rs.on('end', () => {
        ws.end();
    });

    ws.on('drain', () => {
        rs.resume();
    })
}

那是不是每次我们使用流都需要写这么多的代码，当然不是。官方为可读流提供了一个 pipe(ws) 方法，pipe 方法接收一个可写流，它的作用就是将可读流中数据写入到可写流中去，并且它内部有做速度差异的处理。所以上面的写法可以改为下面的版本

const fs = require('fs');

function copy(source, target) {
    const rs = fs.createReadStream(source);
    const ws = fs.createWriteStream(target);

    rs.pipe(ws);
}

当我们调用 pipe 方法时，会触发可写流的 pipe 事件。pipe 的实现参考如下

Readable.prototype.pipe = function(ws) {
    this.on('data', data => {
        if (!ws.write(data)) {
            this.pause();
        }
    });

    ws.on('drain', () => {
        this.resume();
    });

    // 触发 pipe 事件
    ws.emit('pipe', this);

    // 返回可写流，以支持链式调用
    return ws;
}

这里给出官网画的一个有关 pipe 的流程图

                                                     +===================+
                         x-->  Piping functions   +-->   src.pipe(dest)  |
                         x     are set up during     |===================|
                         x     the .pipe method.     |  Event callbacks  |
  +===============+      x                           |-------------------|
  |   Your Data   |      x     They exist outside    | .on('close', cb)  |
  +=======+=======+      x     the data flow, but    | .on('data', cb)   |
          |              x     importantly attach    | .on('drain', cb)  |
          |              x     events, and their     | .on('unpipe', cb) |
+---------v---------+    x     respective callbacks. | .on('error', cb)  |
|  Readable Stream  +----+                           | .on('finish', cb) |
+-^-------^-------^-+    |                           | .on('end', cb)    |
  ^       |       ^      |                           +-------------------+
  |       |       |      |
  |       ^       |      |
  ^       ^       ^      |    +-------------------+         +=================+
  ^       |       ^      +---->  Writable Stream  +--------->  .write(chunk)  |
  |       |       |           +-------------------+         +=======+=========+
  |       |       |                                                 |
  |       ^       |                              +------------------v---------+
  ^       |       +-> if (!chunk)                |    Is this chunk too big?  |
  ^       |       |     emit .end();             |    Is the queue busy?      |
  |       |       +-> else                       +-------+----------------+---+
  |       ^       |     emit .write();                   |                |
  |       ^       ^                                   +--v---+        +---v---+
  |       |       ^-----------------------------------<  No  |        |  Yes  |
  ^       |                                           +------+        +---v---+
  ^       |                                                               |
  |       ^               emit .pause();          +=================+     |
  |       ^---------------^-----------------------+  return false;  <-----+---+
  |                                               +=================+         |
  |                                                                           |
  ^            when queue is empty     +============+                         |
  ^------------^-----------------------<  Buffering |                         |
               |                       |============|                         |
               +> emit .drain();       |  ^Buffer^  |                         |
               +> emit .resume();      +------------+                         |
                                       |  ^Buffer^  |                         |
                                       +------------+   add chunk to queue    |
                                       |            <---^---------------------<
                                       +============+

实现流

在本节中我们来实现具体的流，通过实现流可以进一步加深对 Stream 内部工作细节的理解。

实现可读流

上面我们都是通过 fs.createReadableStream() 方法来得到一个可读流的，在这里我们自己实现一个可读流。实现可读流只需要继承 Readable 类，然后实现 _read() 方法即可

const { Readable } = require(&#39;stream&#39;);

class IeteratorReadableStream extends Readable {
    constructor(iterator) {
        super();
        this.iterator = iterator;
    }

    _read() {
        let data = this.iterator.next();
        // console.log(data);
        if(data.done) {
            this.push(null);
        } else {
            // 必须 push 字符串或者 Buffer
            this.push(data.value+&#39;&#39;);
        }
    }
}

module.exports = IeteratorReadableStream;

上述我们实现了一个可读流，可读流接收一个迭代器作为参数，这个迭代器作为这个可读流的数据源。可读流会自动的调用 _read 获取数据，在 _read 方法中我们从迭代器中获取数据，并且调用了 push 方法，该方法的作用就是将数据放入到缓存区中，只能向其中 push 字符串或者 Buffer，当我们向其中 push null 时就表示数据已经被全部读取完毕。

所以可读流的执行逻辑为，每次调用 _read 方法从数据源读取数据，并将数据存入缓存区，然后触发 data 事件，将缓存区中的数据作为参数传递给 data 事件绑定的回调函数，循环上述过程直到向缓存区 push null 时，就表示数据源中的数据已经被读取完毕，此时会触发 end 事件。

我们创建一个迭代器作为数据源传入

const IeteratorReadableStream = require(&#39;./IteratorReadableStream&#39;);

function *getData() {
    for(let i = 0; i < 5; i++) {
        yield i;
    }
}

let rs = new IeteratorReadableStream(getData());

rs.on(&#39;data&#39;, data => {
    console.log(data.toString());
});

rs.on(&#39;end&#39;, () => {
    console.log("迭代结束");
});

输出为

0
1
2
3
4
迭代结束

实现可写流

实现可写流的过程同实现可读流的过程类似，首先需要继承 Writable 类，接着实现 _write 方法即可

const fs = require(&#39;fs&#39;);
const { Writable } = require(&#39;stream&#39;);

class FileWritableStream extends Writable {
    constructor(filepath) {
        super();
        this.filepath = filepath;
    }

    _write(chunk, encoding, callback) {
        fs.appendFile(this.filepath, chunk, {
            encoding
        }, callback)
    }
}

上面我们实现了一个可写流，这个可写流接收一个文件路径作为参数，它的作用就是向这个文件中追加数据，每次当我们调用可写流的 write() 方法时，它会向缓冲区写入数据，当达到阈值时，便会调用 _write() 方法将数据新增到文件中。

process.stdin.pipe(new FileWritableStream(&#39;c.txt&#39;));

上面这行代码的作用就是将从标准输入的字符输出到 c.txt 中。

实现双工流

Duplex Stream 既可以作为可读流，也可以作为可写流，并且它的输入与输出之间可以没有关系。Duplex Stream 继承了 Readable，并且拥有 Writable 的所有，我们只要分别实现 _read() 和 _write() 方法即可

const { Duplex } = require(&#39;stream&#39;);

class CustomDuplexStream extends Duplex {
    constructor() {
        super();
        this.currentCharCode = 65;
    }

    _read() {
        if(this.currentCharCode <= 90) {
            this.push(String.fromCharCode(this.currentCharCode++))
        } else {
            this.push(null);
        }
    }

    _write(chunk, encoding, callback) {
        console.log(chunk.toString());
        callback();
    }
}

上面双工流的可读流部分就是将大写的 26 个字母添加进了缓存区，而可写流部分就是直接将数据输出到控制台。可见双工流可读流与可写流之间并没有任何的关系

const dp = new CustomDuplexStream();

dp.write("1");
dp.write("2");
dp.end();

dp.pipe(process.stdout);

输出为

1
2
ABCDEFGHIJKLMNOPQRSTUVWXYZ

实现转换流

Tranform Stream 是 Duplex 的特例，它也是一个双工流，不过它的输入和输出之间有关联，它的内部通过 _transform() 方法将可写流接收到的数据经过转换后传入到可读流中，所以我们要实现转换流，只需要实现 _transform() 方法即可

const { Transform } = require(&#39;stream&#39;);

class UpperTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        this.push(chunk.toString().toUpperCase());
        callback();
    }
}

上面我们实现了一个转换流，它可以将输入的小写字符转化为大写字符然后输出

const ts = new UpperTransformStream();
const rs = fs.createReadStream(&#39;a.txt&#39;);
rs.pipe(ts).pipe(process.stdout);

上面程序会读取 a.txt 中的所有字符，将字符转换为大写然后输出在控制台。

转换流在实际应用中还是比较多的，这里介绍一个 Node.js 内置的转换流 zlib，它的作用对文件进行解压缩，将文件压缩为压缩文件，或者将压缩文件解压为正常文件，这不就是一个典型的转换流嘛！

const zlib = require(&#39;zlib&#39;);
const fs = require(&#39;fs&#39;);

const args = process.argv.slice(2);

const source = fs.createReadStream(args[0]);
const target = fs.createWriteStream(args[1]);
const gzip = zlib.createGzip();

source.pipe(gzip).pipe(target);

我们可以通过

node gzip.js Graph.md Graph.md.gz

来运行上面的程序，它可以将 Graph.md 使用 gzip 压缩为 Graph.md.gz。

Node.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。

文件大小从 201KB 压缩到了 51KB。

同样的我们也可以通过 zlib.createGunzip() 来创建一个解压缩的转换流，具体细节同压缩文件相同，不做介绍。

本篇文章到此结束，想必到这里已经对 Stream 的使用已经有所了解了，但是本篇文章并没有列举所有有关 Stream 的 API，如果想更加详细的了解 Stream 的 API，那么接下去就可以阅读官方文档（http://nodejs.cn/api/stream.html）了。

更多node相关知识，请访问：nodejs 教程！！

以上がNode.js でストリーム (読み取り可能、書き込み可能、​​二重および変換ストリーム) を実装する方法について話しましょう。の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

声明
この記事は掘金社区で複製されています。侵害がある場合は、admin@php.cn までご連絡ください。
関連記事
JavaScriptとWeb：コア機能とユースケースJavaScriptとWeb：コア機能とユースケースApr 18, 2025 am 12:19 AM

Web開発におけるJavaScriptの主な用途には、クライアントの相互作用、フォーム検証、非同期通信が含まれます。 1）DOM操作による動的なコンテンツの更新とユーザーインタラクション。 2）ユーザーエクスペリエンスを改善するためにデータを提出する前に、クライアントの検証が実行されます。 3）サーバーとのリフレッシュレス通信は、AJAXテクノロジーを通じて達成されます。

JavaScriptエンジンの理解：実装の詳細JavaScriptエンジンの理解：実装の詳細Apr 17, 2025 am 12:05 AM

JavaScriptエンジンが内部的にどのように機能するかを理解することは、開発者にとってより効率的なコードの作成とパフォーマンスのボトルネックと最適化戦略の理解に役立つためです。 1）エンジンのワークフローには、3つの段階が含まれます。解析、コンパイル、実行。 2）実行プロセス中、エンジンはインラインキャッシュや非表示クラスなどの動的最適化を実行します。 3）ベストプラクティスには、グローバル変数の避け、ループの最適化、constとletsの使用、閉鎖の過度の使用の回避が含まれます。

Python vs. JavaScript：学習曲線と使いやすさPython vs. JavaScript：学習曲線と使いやすさApr 16, 2025 am 12:12 AM

Pythonは、スムーズな学習曲線と簡潔な構文を備えた初心者により適しています。 JavaScriptは、急な学習曲線と柔軟な構文を備えたフロントエンド開発に適しています。 1。Python構文は直感的で、データサイエンスやバックエンド開発に適しています。 2。JavaScriptは柔軟で、フロントエンドおよびサーバー側のプログラミングで広く使用されています。

Python vs. JavaScript：コミュニティ、ライブラリ、リソースPython vs. JavaScript：コミュニティ、ライブラリ、リソースApr 15, 2025 am 12:16 AM

PythonとJavaScriptには、コミュニティ、ライブラリ、リソースの観点から、独自の利点と短所があります。 1）Pythonコミュニティはフレンドリーで初心者に適していますが、フロントエンドの開発リソースはJavaScriptほど豊富ではありません。 2）Pythonはデータサイエンスおよび機械学習ライブラリで強力ですが、JavaScriptはフロントエンド開発ライブラリとフレームワークで優れています。 3）どちらも豊富な学習リソースを持っていますが、Pythonは公式文書から始めるのに適していますが、JavaScriptはMDNWebDocsにより優れています。選択は、プロジェクトのニーズと個人的な関心に基づいている必要があります。

C/CからJavaScriptへ：すべてがどのように機能するかC/CからJavaScriptへ：すべてがどのように機能するかApr 14, 2025 am 12:05 AM

C/CからJavaScriptへのシフトには、動的なタイピング、ゴミ収集、非同期プログラミングへの適応が必要です。 1）C/Cは、手動メモリ管理を必要とする静的に型付けられた言語であり、JavaScriptは動的に型付けされ、ごみ収集が自動的に処理されます。 2）C/Cはマシンコードにコンパイルする必要がありますが、JavaScriptは解釈言語です。 3）JavaScriptは、閉鎖、プロトタイプチェーン、約束などの概念を導入します。これにより、柔軟性と非同期プログラミング機能が向上します。

JavaScriptエンジン：実装の比較JavaScriptエンジン：実装の比較Apr 13, 2025 am 12:05 AM

さまざまなJavaScriptエンジンは、各エンジンの実装原則と最適化戦略が異なるため、JavaScriptコードを解析および実行するときに異なる効果をもたらします。 1。語彙分析：ソースコードを語彙ユニットに変換します。 2。文法分析：抽象的な構文ツリーを生成します。 3。最適化とコンパイル：JITコンパイラを介してマシンコードを生成します。 4。実行：マシンコードを実行します。 V8エンジンはインスタントコンピレーションと非表示クラスを通じて最適化され、Spidermonkeyはタイプ推論システムを使用して、同じコードで異なるパフォーマンスパフォーマンスをもたらします。

ブラウザを超えて：現実世界のJavaScriptブラウザを超えて：現実世界のJavaScriptApr 12, 2025 am 12:06 AM

現実世界におけるJavaScriptのアプリケーションには、サーバー側のプログラミング、モバイルアプリケーション開発、モノのインターネット制御が含まれます。 2。モバイルアプリケーションの開発は、ReactNativeを通じて実行され、クロスプラットフォームの展開をサポートします。 3.ハードウェアの相互作用に適したJohnny-Fiveライブラリを介したIoTデバイス制御に使用されます。

next.jsを使用してマルチテナントSaaSアプリケーションを構築する（バックエンド統合）next.jsを使用してマルチテナントSaaSアプリケーションを構築する（バックエンド統合）Apr 11, 2025 am 08:23 AM

私はあなたの日常的な技術ツールを使用して機能的なマルチテナントSaaSアプリケーション（EDTECHアプリ）を作成しましたが、あなたは同じことをすることができます。 まず、マルチテナントSaaSアプリケーションとは何ですか？ マルチテナントSaaSアプリケーションを使用すると、Singの複数の顧客にサービスを提供できます

See all articles

ホットAIツール

Undresser.AI Undress

Undresser.AI Undress

リアルなヌード写真を作成する AI 搭載アプリ

AI Clothes Remover

AI Clothes Remover

写真から衣服を削除するオンライン AI ツール。

Undress AI Tool

Undress AI Tool

脱衣画像を無料で

Clothoff.io

Clothoff.io

AI衣類リムーバー

AI Hentai Generator

AI Hentai Generator

AIヘンタイを無料で生成します。

もっと見る

人気の記事

R.E.P.O.説明されたエネルギー結晶と彼らが何をするか（黄色のクリスタル）
1 か月前By尊渡假赌尊渡假赌尊渡假赌
R.E.P.O.最高のグラフィック設定
1 か月前By尊渡假赌尊渡假赌尊渡假赌
アサシンのクリードシャドウズ：シーシェルリドルソリューション
2週間前ByDDD
Windows11 KB5054979の新しいものと更新の問題を修正する方法
2週間前ByDDD
Will R.E.P.O.クロスプレイがありますか？
1 か月前By尊渡假赌尊渡假赌尊渡假赌
もっと見る

ホットツール

WebStorm Mac版

WebStorm Mac版

便利なJavaScript開発ツール

ドリームウィーバー CS6

ドリームウィーバー CS6

ビジュアル Web 開発ツール

AtomエディタMac版ダウンロード

AtomエディタMac版ダウンロード

最も人気のあるオープンソースエディター

DVWA

DVWA

Damn Vulnerable Web App (DVWA) は、非常に脆弱な PHP/MySQL Web アプリケーションです。その主な目的は、セキュリティ専門家が法的環境でスキルとツールをテストするのに役立ち、Web 開発者が Web アプリケーションを保護するプロセスをより深く理解できるようにし、教師/生徒が教室環境で Web アプリケーションを教え/学習できるようにすることです。安全。 DVWA の目標は、シンプルでわかりやすいインターフェイスを通じて、さまざまな難易度で最も一般的な Web 脆弱性のいくつかを実践することです。このソフトウェアは、

Safe Exam Browser

Safe Exam Browser

Safe Exam Browser は、オンライン試験を安全に受験するための安全なブラウザ環境です。このソフトウェアは、あらゆるコンピュータを安全なワークステーションに変えます。あらゆるユーティリティへのアクセスを制御し、学生が無許可のリソースを使用するのを防ぎます。

もっと見る

ホットトピック

Gmailメールのログイン入り口はどこですか？
7546
15
CakePHP チュートリアル
1381
52
Steamのアカウント名の形式は何ですか
83
11
Win11 Activation Key Permanent
57
19
NYTの接続はヒントと回答です
21
90
もっと見る