Explanation of angular.json file (code example)

This article brings you an explanation (code example) about the angular.json file. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

After the Angular CLI 6 version, the original angular-cli.json was replaced by angular.json, and the fields in it have changed a lot. If you don’t understand the basic composition, or directly Copying the old version of the code into the new version of the workspace will cause some very unfriendly errors.

This change is mainly due to the introduction of the monorepo (one space manages multiple projects) development model in Angular CLI. That is, using ng new is equivalent to a large workspace, which is managed through angular.json configuration. Various projects or component libraries from ng generate application | library.

In fact, the advantages of this model are very obvious. For example, when a company has multiple management platforms or products, this method can unify the environment of each project, and the components shared between each project can also be maintained uniformly. , all projects share npm packages and typescript configurations.

The structure of monorepo is as follows:

But in fact, most people still maintain one project in one workspace, so this is not included here. So important, I just want to say that the changes to the json file are for the new model.

Some fields of Angular.json

When you create a new workspace, a project and the corresponding e2e project will be created in the root directory by default. The initial angular.json structure is as follows (the omitted part of the configuration code)

{
    "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
    "version": 1,
    "newProjectRoot": "projects",
    "projects": {
        "xxxx": {
            "root": "",
            "sourceRoot": "src",
            "projectType": "application",
            "prefix": "app",
            "schematics": {},
            "architect": {}
        }
    },
    "defaultProject": "xxxx"
}

This is part of the configuration properties. I will simply record them in order so that they can be easily referenced later.

$schema

points to a JSON Schema file, which describes all fields and constraints of angular.json.

In fact, it can be compared to a file with a "type prompt" function. As long as an IDE or editor that supports this function will give corresponding prompts when writing the angular.json file.

version

Set version

newProjectRoot

The path where the new project is located.

When using ng generate application | library to create a new project, it will be automatically assembled into the set newProjectRoot directory

projects

Place Configuration of all projects. One of the projects is a sub-item, for example, xxxx is a project, which is automatically generated when it is created.

{
    "projects": {
        "xxxx": {
            "root": "",
            "sourceRoot": "src",
            "projectType": "application",
            "prefix": "app",
            "schematics": {},
            "architect": {}
        }
    }
}

In a single configuration, some automated operations can be implemented through flexible configuration and some commands built into the CLI.

root

represents the "root directory" of the project, which is the location of the project, or the parent directory of the project source code. The project's root directory contains some specific configuration.

sourceRoot

The directory where the project source code is located, usually the src directory is used by default.

projectType

Indicate whether this project is an application or a library

prefix

Use ng generate component | The default selector prefix when directive generates components or instructions. Usually the components or instructions we create using commands are in the app-xxx format. We can manually change it here to make the entire project effective.

schematics

The instructions in the CLI to generate components, instructions, modules and other files are implemented using @angular-devkit/schematics. These instructions usually come with some shortcut configurations , for example, a command to generate components: ng g c --spec=false --styleext=scss. This command can directly generate a component without a test file and using scss as the style file. It would be troublesome if you have to manually enter these configurations every time, so angular.json provides the schematics attribute to uniformly set some command configurations for generating classes.

The schematics here are for a single project. The entire angular.json also has this field, which takes effect in all projects by default.

CLI presets several sets of options, and we can configure different options:

@schematics/angular:component

@schematics/angular:class

@schematics/angular:directive

@schematics/angular:guard

@schematics/angular:module

@schematics/angular:pipe

@schematics/angular:service

Take component as an example. If you want to achieve the effect of unified ng g c --spec=false --styleext=scss, you can configure it as follows:

{
    "schematics": {
        "@schematics/angular:component": {
             "styleext": "less",
             "spec": false
        }
    }
}

Then you can Directly use ng g c to directly generate the corresponding components.

architect

Contains several sets of CLI-related project automation command configurations, such as local running, compilation, testing, etc. Several sets of command configurations are preset by default, such as build, serve, etc.:

{
    "architect":{
        "build":{},
        "serve":{},
        "extract-i18n":{},
        "test":{},
        "lint":{}
    }
}

Configuration attributes

Each configuration item has 3 field attributes: builder, options , configurations, such as the default build command configuration:

{
    "architect": {
        "build": {
            "builder": "@angular-devkit/build-angular:browser",
            "options": {
                "outputPath": "dist/testApp",
                "index": "src/index.html",
                "main": "src/main.ts",
                "polyfills": "src/polyfills.ts",
                "tsConfig": "src/tsconfig.app.json",
                "assets": [
                    "src/favicon.ico",
                    "src/assets"
                ],
                "styles": [
                    "src/styles.css"
                ],
                "scripts": []
             },
             "configurations": {
                 "production": {
                     "fileReplacements": [
                         {
                             "replace": "src/environments/environment.ts",
                             "with": "src/environments/environment.prod.ts"
                         }
                     ],
                     "optimization": true,
                     "outputHashing": "all",
                     "sourceMap": false,
                     "extractCss": true,
                     "namedChunks": false,
                     "aot": true,
                     "extractLicenses": true,
                     "vendorChunk": false,
                     "buildOptimizer": true
                  }
              }
          }
      }
}

This is the configuration generated by the project by default.

builder代表要执行的内置程序，因为CLI内置了一些自动化工具，architect只是提供了一个facade模式（通俗地讲，就是开发者不需要知道内部的复杂实现）给开发者配置使用，本质上还是调用的内置工具。

options代表针对当前builder要配置的配置项，调用不同的内置程序，是需要传对应的配置项的，由于配置项很多，这里也不会列出。

configurations代表这个命令的多种调用模式，在此配置里，我们可以定义不同的别名，然后使用不同的配置（配置的字段还是属于options里的），最后在使用命令时便可以手动选择不同的模式。

如何使用

CLI其实内置了几个快捷命令来对应默认生成的配置如ng serve、ng build等等，如果是我们额外自定义的配置，则可以使用ng run :[:configurations] [其他配置]
命令来实现，其中project和architect为必填，configurations为选填。

比如我们简单额外自定义一个本地运行的服务器命令：

{
    "architect":{
        "myServe":{
            "builder": "@angular-devkit/build-angular:dev-server",
            "options": {
                "browserTarget": "xxxx:build",
                "port": 8800
            },
            "configurations": {
                "port1": {
                    "port": 8801
                },
                "port2": {
                    "port": 880
                }
            }
        }
    }
}

配置使用了内置的运行本地服务器程序，然后使用默认的build配置，加上自定义的运行端口，另外加上两个不同模式，运行不同端口。

使用ng run xxxx:myServe可以正常运行本地服务器跑项目，端口是8800
使用ng run xxxx:myServe:port1端口是8801

当然，我们还可以直接使用额外的命令行配置直接覆盖已经定义的配置：
ng run xxxx:myServe:port1 --port=8808

这里的例子只是为了简单了解下architect的用法。

defaultProject

默认项目，当使用一些CLI命令没有指定项目名称时，默认指向的项目。

schema.json

其实我只是为了记录自己有点印象的属性，整个angular.json还有很多其他的字段，如果想要全面了解，我们可以直接打开$schema所指向的文件，里面详细地展示了各种字段的类型、配置以及描述说明。

The above is the detailed content of Explanation of angular.json file (code example). For more information, please follow other related articles on the PHP Chinese website!