Beispiel-Tutorial für die ThinkJS-Entwicklungskonfiguration
Konfigurationsdateien werden durch Module definiert
thinkjs ermöglicht es Entwicklern, ihre eigenen Parameter direkt darunter zu konfigurieren src/common/config/
und js-Dateien direkt hinzuzufügen. Der Dateiname muss nur die Anforderungen an den JSON-Attributnamen und die Datei erfüllen Inhalt folgt Das Format ist wie folgt:
// 新增文件 assets.js 键入如下内容'use strict';export default { // key: value};
Der Dateiinhalt muss nur der Definition eines JSON-Objektformats entsprechen. Schauen wir uns eine Konfigurationsdefinition von log4js an:
// log4js.js'use strict';export default { appenders: [{ type : "console", category: "console"},// 定义一个日志记录器{ type : "dateFile", // 日志文件类型,可以使用日期作为文件名的占位符 filename : "logs/", // 日志文件名,可以设置相对路径或绝对路径 pattern : "debug/yyyyMMddhh.txt", // 占位符,紧跟在filename后面 absolute : true, // filename是否绝对路径 alwaysIncludePattern: true, // 文件名是否始终包含占位符 category : "logInfo" // 记录器名} ], levels : {logInfo: "DEBUG" } // 设置记录器的默认显示级别,低于这个级别的日志,不会输出}
Konfigurationsdateien sind statische Einstellungen und speichern im Allgemeinen Einstellungsparameter, die sich nicht häufig ändern (natürlich die Werte von Konfigurationsparametern). kann im Speicher geändert werden, wie im Folgenden ausführlich erläutert wird).
Außerdem handelt es sich bei der Konfigurationsdatei um eine JS-Datei, die Variablendefinitionen im ES6-Format exportiert, und nicht um eine JSON-Datei. Der Vorteil besteht darin, dass Sie Kommentare hinzufügen können, die mit // beginnen.
Wenn Sie vorsichtig sind, müssen Sie bemerkt haben: Zusätzlich zu src/common/config
gibt es auch einen Ordner src/home/
unter dem Modul config
.
Im Allgemeinen ist es sinnvoller, entsprechend dem Umfang der Konfigurationsdatei zu definieren und anzuordnen.
Zum Beispiel: Konfigurationen, die von allen Modulen verwendet werden, sollten besser unter src/common/config
platziert werden, während Konfigurationen, die nur für das Home-Modul verwendet werden, eher unter src/home/config
platziert werden sollten.
Wenn zu viele Konfigurationsdateien vorhanden sind, müssen wir auf die Ladereihenfolge mehrerer Konfigurationsdateien achten.
Ladereihenfolge der Konfigurationsdateien
Die offizielle Website beschreibt die Ladereihenfolge der Konfigurationsdateien wie folgt:
框架默认的配置 -> 项目模式下框架配置 -> 项目公共配置 -> 项目模式下的公共配置 -> 模块下的配置
Fragen Sie Ich zuerst Frage: Worauf beziehen sich diese fünf Konfigurationen?
Die ersten beiden können ignoriert werden. Es handelt sich um die Konfigurationseinstellungen des thinkjs-Frameworks selbst. Normalerweise gibt es keine Konfigurationsparameter, die unser Projekt verwenden wird.
Der dritte und vierte sind die Standardkonfigurationskonfigurationsordner in verschiedenen Projekterstellungsmodi (Informationen zum Projekterstellungsmodus finden Sie unter Node.js Domestic MVC Framework ThinkJS Development Introduction (Jingxiu.com)), Speicherort in:
# normal modethinkjs_normal/src/config/*# module modethinkjs_module/src/common/config/*
Das letzte bezieht sich auf das Projekt im Modulmodus. Jedes Modul hat seine eigene Konfiguration. Der Speicherort ist:
thinkjs_module/src/home/config/*
zusammengeführt werden (beachten Sie den fett gedruckten Text).
Wenn also mehrere Konfigurationsdateien vorhanden sind, müssen Sie darauf achten,versuchen, die Schlüssel (d. h. Attributnamen) der Konfigurationsparameter nicht zu wiederholen , da entsprechend der Ladereihenfolge die Der Wert des später geladenen Schlüssels überschreibt den ersten. Der Wert des geladenen Schlüssels führt zu unerwünschten Ergebnissen.
Tipps: Das Tutorial erklärt hauptsächlich die Entwicklungsmethode im Modulmodus.
Konfigurationsdateien automatisch wechseln Wie bereits erwähnt, können wir Konfigurationsdateien unter platzieren. Alle Konfigurationsparameter können in einer Datei abgelegt oder auf mehrere verteilt werden Dateien in einer Datei. src/common/config
drei Konfigurationsparameterumgebungen bereit, nämlich Entwicklungskonfiguration src/common/config/env/
, Produktionskonfiguration development
und Testkonfiguration production
, die unsere kontinuierliche Integration speichern können. testing
src/common/config/env/development.js
{ "scripts": {"start": "node www/development.js?1.1.11","compile": "babel src/ --out-dir app/","watch-compile": "node -e \"console.log('<npm run watch-compile> no longer need, use <npm start> command direct.');console.log();\"","watch": "npm run watch-compile" }}
-Attribut die Details definiert, wenn wir direkt Was tatsächlich ausgeführt wird, ist der Befehl scripts.start
. npm start
node www/development.js
Gemäß dem Grundsatz, nach Antworten zu fragen, werfen Sie einen Blick auf den Inhalt dieser Datei:
:-)
生产配置
生产配置文件是:src/common/config/env/production.js
明白了开发配置的原理,也就不难明白生产配置了。
使用 node www/production.js
命令可以告诉 thinkjs 现在运行的是生产环境。
同理,生产配置中的参数名(属性名)一般与开发配置一样,只是值不同而已。
比较常见的是数据库连接,本地开发时连接的是测试库,而生产环境中连接的是生产库,不同的地址、用户、密码和库名,这些都是要交给运维人员来管理了。
测试配置
测试配置文件是:src/common/config/env/testing.js
明白了前两个配置,这个也不难明白~
使用 node www/testing.js
命令可以告诉 thinkjs 现在运行的是测试环境。
定义和使用配置文件
前面其实有介绍过配置文件的分布原则和定义方法,只要确保不与系统特定配置冲突即可自由定义。
系统特定配置
下面是 thinkjs 默认的配置文件清单,这些系统特定配置都是有相应的使用场景和参数设置,详细说明及完整参数详见:
src/common/config/├── config.js # 可以放置自己的配置├── db.js # 数据库连接├── env # 运行时配置,下面会详述│ ├── development.js│ ├── production.js│ └── testing.js├── error.js # 错误配置├── hook.js # 钩子配置├── locale # 多语言版配置│ └── en.js├── session.js└── view.js # 视图文件配置
自定义配置
一般做法是使用带有层级的配置定义来组织配置参数(当然你一定要把全部参数都放在根下面也不是不可以),参见如下配置:
// development.js'use strict';export default { site_name: "", site_title: "", site_keywords: "", site_description: "", db: { // 这里的配置替代 db.jstype : 'mysql',log_sql: true, //是否记录 sql 语句adapter: { mysql: {host : '127.0.0.1',port : '3306',database: '',user : '',password: '',prefix : 'thinkjs_',encoding: 'utf8' }} }, jwt: { // 第三方模块的公共定义options: { algorithm: 'HS128', expiresIn: '7d'} }, pay: {// 定义与在线支付接口相关的参数 }, backend: {// 定义管理后台相关的参数 }, home: {// 定义前端网站相关的参数 }, rest: {// 定义 REST API 相关的参数 }, task: {// 定义 crond 相关的参数 }};
配置参数按照层次组织之后,需要注意的一点是:获取配置的时候,不能无限制的 this.config(参数.参数.参数.参数)
下去,详见下面读取配置的几种方式描述。
几种读取配置的方式
配置文件定义之后,需要在项目运行的特别业务中读取(也可以设置)到配置参数的值,根据读取配置的位置的不同,thinkjs 提供了以下几种读取方式。
this.config()
这是使用率最高的读取配置方法,绝大多数位置都可以使用此方法来读取配置,比如 controller
logic
model
service
middleware
等地方。
// 配置 development.jslet dbOpt = this.config('db');let jwtOpt = this.config('jwt.options');
这里有一点需要注意:thinkjs 只能解析两层配置参数,超过的层级不予解析(源码中写死了仅返回两层)。
// 配置 development.jslet jwtOpt = this.config('jwt.options');console.log(jwtOpt);// 读取成功,打印:// {// options: {// algorithm: 'HS128',// expiresIn: '7d'// }// }let jwtOptAlg = this.config('jwt.options.algorithm');console.log(jwtOptAlg);// 超过三层,读取失败,只能读取到两层内容,打印:// {// options: {// algorithm: 'HS128',// expiresIn: '7d'// }// }jwtOptAlg = jwtOpt['algorithm'];console.log(jwtOptAlg);// 正确的读取方式,打印:// HS128
think.config()
think.config 方法可以:
无须考虑当前位置来读取配置参数(其内部运行方式类似 this.config )
跨模块读取配置参数
对于前者可以无须思考当前所在的模块,更自由的读取配置参数。
对于后者则对开发多模块协作有着比较重要的意义,配置参数只有一份,不可能向不同的模块复制相同的配置,因此需要“一处配置、多处可用”。因此无须考虑“我在哪里读取配置”,只要考虑“我要读取哪里的配置”即可。
// 配置文件:src/home/config/assets.jslet siteName = think.config('assets.site_name', undefined, 'home');
方法的第二个参数设置为 undefined
是为了避免将读取动作变为设置动作。
方法的第三个参数标明了这个配置参数在哪个模块下面,一旦给定此参数,thinkjs 会认为 src/home/config/
下面的配置是你需要读取的目标。
http.config()
http.config 方法实质上是 think.config() 的一个别名,可以读取和设置配置参数。
避免踩坑之正确读取参数
如果不能理解 thinkjs 设计配置文件读取策略的情况下,会无意中踩坑,如下便是一个例子,代码说话。
假设有两个配置文件 src/common/config/assets.js
和 src/home/config/assets.js
,其中有着一样的属性名:
// src/common/config/assets.jsexport default { "site_title": "my site"};// src/home/config/assets.jsexport default { "site_title": "my test"};// 两个配置参数属性名一样的情况下// 使用不同的读取方式// 注意 config 方法的上下文对象的不同// 会导致读取的结果的不同// src/home/controller/index.jslet assets = this.config('assets');let siteTitle = assets['site_title'];console.log('siteTitle is: ', siteTitle);// 打印:// my test// src/home/controller/index.jslet assets = think.config('assets', undefined, 'common');let siteTitle = assets['site_title'];console.log('siteTitle is: ', siteTitle);// 打印:// my site
明白了 thinkjs 配置文件加载顺序,就不会对上面发生的情况惊讶了~
如果你实在懒得去思考 this.config
和 think.config
两者的分别,建议你干脆使用后者,当读取参数只传入第一个参数时,它的表现与前者一致。这样貌似更有利于代码的维护~
避免踩坑之动态修改配置参数
当读取到了配置参数后,当然是可以动态修改其为新的值,以让后续的处理都读到新的值。动态修改方法也很简单:config 方法的第二个参数就是给定的新值。
let siteTitle = this.config('assets.site_title');console.log(siteTitle);// 打印:// my testthis.config('assets.site_title', 'test 123');siteTitle = this.config('assets.site_title');console.log(siteTitle);// 打印:// test 123
上面的动态修改方法其实平淡无奇,来看看更有趣的修改方法,如下:
let siteAuthor = this.config('assets.site_author');console.log(siteAuthor);// 打印:// {// name: 'xxuyou.com',// email: 'cap@xxuyou.com'// }siteAuthor['name'] = 'cap';siteAuthor = this.config('assets.site_author');console.log(siteAuthor);// 打印:// {// name: 'cap',// email: 'cap@xxuyou.com'// }
假如上面的代码片段修改一下写法,就可以得到预期的效果,如下:
let siteAuthor = think.extend({}, this.config('assets.site_author')); // <-- 不同点在这里console.log(siteAuthor);// 打印:// {// name: 'xxuyou.com',// email: 'cap@xxuyou.com'// }siteAuthor['name'] = 'cap';siteAuthor = this.config('assets.site_author');console.log(siteAuthor);// 打印:// {// name: 'xxuyou.com',// email: 'cap@xxuyou.com'// }
Unabhängig davon, wer dieser think.extend
ist, warum hat das Ändern der Variablen auf der linken Seite des Gleichheitszeichens den gleichen Effekt wie das direkte Ändern der Konfigurationsmethode?
Der Grund ist eigentlich ganz einfach:
thinkjs speichert Konfigurationsparameter intern zwischen. Der Wert des Konfigurationsparameters
ist ein
Object
stattString
.
OK~
Sprachpaket
Das Sprachpaket selbst kann eigentlich separat als i18n beschrieben werden, aber aufgrund der Internationalisierung in der tatsächlichen Entwicklung und sogar Architekturprozess Es wird selten behandelt und daher hier kurz beschrieben.
src/config/locale/en.js
Die standardmäßige englische Sprachumgebung des Systems, die relevante Sprachvorlagen definiert.
src/config/locale/zh-CN.js
Aus Gründen der Standardisierung wird empfohlen, diese Sprachvorlagendatei manuell einzurichten und den Parameter src/common/config/local.js
in bis default
das heißt Diese Sprachvorlage kann aktiviert werden. zh-CN
Das obige ist der detaillierte Inhalt vonBeispiel-Tutorial für die ThinkJS-Entwicklungskonfiguration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Python eignet sich besser für Anfänger mit einer reibungslosen Lernkurve und einer kurzen Syntax. JavaScript ist für die Front-End-Entwicklung mit einer steilen Lernkurve und einer flexiblen Syntax geeignet. 1. Python-Syntax ist intuitiv und für die Entwicklung von Datenwissenschaften und Back-End-Entwicklung geeignet. 2. JavaScript ist flexibel und in Front-End- und serverseitiger Programmierung weit verbreitet.

Python und JavaScript haben ihre eigenen Vor- und Nachteile in Bezug auf Gemeinschaft, Bibliotheken und Ressourcen. 1) Die Python-Community ist freundlich und für Anfänger geeignet, aber die Front-End-Entwicklungsressourcen sind nicht so reich wie JavaScript. 2) Python ist leistungsstark in Bibliotheken für Datenwissenschaft und maschinelles Lernen, während JavaScript in Bibliotheken und Front-End-Entwicklungsbibliotheken und Frameworks besser ist. 3) Beide haben reichhaltige Lernressourcen, aber Python eignet sich zum Beginn der offiziellen Dokumente, während JavaScript mit Mdnwebdocs besser ist. Die Wahl sollte auf Projektbedürfnissen und persönlichen Interessen beruhen.

Die Verschiebung von C/C zu JavaScript erfordert die Anpassung an dynamische Typisierung, Müllsammlung und asynchrone Programmierung. 1) C/C ist eine statisch typisierte Sprache, die eine manuelle Speicherverwaltung erfordert, während JavaScript dynamisch eingegeben und die Müllsammlung automatisch verarbeitet wird. 2) C/C muss in den Maschinencode kompiliert werden, während JavaScript eine interpretierte Sprache ist. 3) JavaScript führt Konzepte wie Verschlüsse, Prototypketten und Versprechen ein, die die Flexibilität und asynchrone Programmierfunktionen verbessern.

Unterschiedliche JavaScript -Motoren haben unterschiedliche Auswirkungen beim Analysieren und Ausführen von JavaScript -Code, da sich die Implementierungsprinzipien und Optimierungsstrategien jeder Engine unterscheiden. 1. Lexikalanalyse: Quellcode in die lexikalische Einheit umwandeln. 2. Grammatikanalyse: Erzeugen Sie einen abstrakten Syntaxbaum. 3. Optimierung und Kompilierung: Generieren Sie den Maschinencode über den JIT -Compiler. 4. Führen Sie aus: Führen Sie den Maschinencode aus. V8 Engine optimiert durch sofortige Kompilierung und versteckte Klasse.

Zu den Anwendungen von JavaScript in der realen Welt gehören die serverseitige Programmierung, die Entwicklung mobiler Anwendungen und das Internet der Dinge. Die serverseitige Programmierung wird über node.js realisiert, die für die hohe gleichzeitige Anfrageverarbeitung geeignet sind. 2. Die Entwicklung der mobilen Anwendungen erfolgt durch reaktnative und unterstützt die plattformübergreifende Bereitstellung. 3.. Wird für die Steuerung von IoT-Geräten über die Johnny-Five-Bibliothek verwendet, geeignet für Hardware-Interaktion.

Ich habe eine funktionale SaaS-Anwendung mit mehreren Mandanten (eine EdTech-App) mit Ihrem täglichen Tech-Tool erstellt und Sie können dasselbe tun. Was ist eine SaaS-Anwendung mit mehreren Mietern? Mit Multi-Tenant-SaaS-Anwendungen können Sie mehrere Kunden aus einem Sing bedienen

Dieser Artikel zeigt die Frontend -Integration mit einem Backend, das durch die Genehmigung gesichert ist und eine funktionale edtech SaaS -Anwendung unter Verwendung von Next.js. erstellt. Die Frontend erfasst Benutzerberechtigungen zur Steuerung der UI-Sichtbarkeit und stellt sicher, dass API-Anfragen die Rollenbasis einhalten

JavaScript ist die Kernsprache der modernen Webentwicklung und wird für seine Vielfalt und Flexibilität häufig verwendet. 1) Front-End-Entwicklung: Erstellen Sie dynamische Webseiten und einseitige Anwendungen durch DOM-Operationen und moderne Rahmenbedingungen (wie React, Vue.js, Angular). 2) Serverseitige Entwicklung: Node.js verwendet ein nicht blockierendes E/A-Modell, um hohe Parallelitäts- und Echtzeitanwendungen zu verarbeiten. 3) Entwicklung von Mobil- und Desktop-Anwendungen: Die plattformübergreifende Entwicklung wird durch reaktnative und elektronen zur Verbesserung der Entwicklungseffizienz realisiert.


Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

VSCode Windows 64-Bit-Download
Ein kostenloser und leistungsstarker IDE-Editor von Microsoft

DVWA
Damn Vulnerable Web App (DVWA) ist eine PHP/MySQL-Webanwendung, die sehr anfällig ist. Seine Hauptziele bestehen darin, Sicherheitsexperten dabei zu helfen, ihre Fähigkeiten und Tools in einem rechtlichen Umfeld zu testen, Webentwicklern dabei zu helfen, den Prozess der Sicherung von Webanwendungen besser zu verstehen, und Lehrern/Schülern dabei zu helfen, in einer Unterrichtsumgebung Webanwendungen zu lehren/lernen Sicherheit. Das Ziel von DVWA besteht darin, einige der häufigsten Web-Schwachstellen über eine einfache und unkomplizierte Benutzeroberfläche mit unterschiedlichen Schwierigkeitsgraden zu üben. Bitte beachten Sie, dass diese Software

SublimeText3 Linux neue Version
SublimeText3 Linux neueste Version

Dreamweaver CS6
Visuelle Webentwicklungstools

MantisBT
Mantis ist ein einfach zu implementierendes webbasiertes Tool zur Fehlerverfolgung, das die Fehlerverfolgung von Produkten unterstützen soll. Es erfordert PHP, MySQL und einen Webserver. Schauen Sie sich unsere Demo- und Hosting-Services an.