Angular使用筆記5_組件(component)和模組(module)
元件、組件(component):每一頁都屬於component(至少一個)
所以若一個網站有200頁就至少會有200個component
每一頁可能又會拆幾個子component( Header component , Menu component)
有點類似封裝成一個自訂客製的tag
一個component會有三個組成元素分別是
class (也就是.ts檔)
template(也就是.html檔)
metadata(中繼資料)->decorator
通常放在.ts檔class上面有點類似data annotation用來描述該class(或property,method)的一些特性
也時常放在一個property或者一個method上面去裝飾
以@NgModule這個decorator來講 當中的metadata又包含
declarations 代表在此模組中要控制的組件有哪些這邊用陣列方式來做設置。
providers 代表一些service的引用添加
imports 代表Module的引入(比方像最開始需要依賴的就是BrowserModule,AppRoutingModule)
模組,模块(module):用來管理component的一個封裝的單位,通常沒有code只會有個宣告
(有點類似dll或namespace封裝很多class進去)
一般都會先建立module再去註冊各個component,module用來封裝angulat的組件。
至少會有一個最根本的Base Module就是 AppModule
Type of the NgModule metadata.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 | export declare interface NgModule { /** * The set of injectable objects that are available in the injector * of this module. * * @see [Dependency Injection guide](guide/dependency-injection) * @see [NgModule guide](guide/providers) * * @usageNotes * * Dependencies whose providers are listed here become available for injection * into any component, directive, pipe or service that is a child of this injector. * The NgModule used for bootstrapping uses the root injector, and can provide dependencies * to any part of the app. * * A lazy-loaded module has its own injector, typically a child of the app root injector. * Lazy-loaded services are scoped to the lazy-loaded module's injector. * If a lazy-loaded module also provides the `UserService`, any component created * within that module's context (such as by router navigation) gets the local instance * of the service, not the instance in the root injector. * Components in external modules continue to receive the instance provided by their injectors. * * ### Example * * The following example defines a class that is injected in * the HelloWorld NgModule: * * ``` * class Greeter { * greet(name:string) { * return 'Hello ' + name + '!'; * } * } * * @NgModule({ * providers: [ * Greeter * ] * }) * class HelloWorld { * greeter:Greeter; * * constructor(greeter:Greeter) { * this.greeter = greeter; * } * } * ``` */ providers?: Provider[]; /** * The set of components, directives, and pipes ([declarables](guide/glossary#declarable)) * that belong to this module. * * @usageNotes * * The set of selectors that are available to a template include those declared here, and * those that are exported from imported NgModules. * * Declarables must belong to exactly one module. * The compiler emits an error if you try to declare the same class in more than one module. * Be careful not to declare a class that is imported from another module. * * ### Example * * The following example allows the CommonModule to use the `NgFor` * directive. * * ```javascript * @NgModule({ * declarations: [NgFor] * }) * class CommonModule { * } * ``` */ declarations?: Array<Type<any> | any[]>; /** * The set of NgModules whose exported [declarables](guide/glossary#declarable) * are available to templates in this module. * * @usageNotes * * A template can use exported declarables from any * imported module, including those from modules that are imported indirectly * and re-exported. * For example, `ModuleA` imports `ModuleB`, and also exports * it, which makes the declarables from `ModuleB` available * wherever `ModuleA` is imported. * * ### Example * * The following example allows MainModule to use anything exported by * `CommonModule`: * * ```javascript * @NgModule({ * imports: [CommonModule] * }) * class MainModule { * } * ``` * */ imports?: Array<Type<any> | ModuleWithProviders<{}> | any[]>; /** * The set of components, directives, and pipes declared in this * NgModule that can be used in the template of any component that is part of an * NgModule that imports this NgModule. Exported declarations are the module's public API. * * A declarable belongs to one and only one NgModule. * A module can list another module among its exports, in which case all of that module's * public declaration are exported. * * @usageNotes * * Declarations are private by default. * If this ModuleA does not export UserComponent, then only the components within this * ModuleA can use UserComponent. * * ModuleA can import ModuleB and also export it, making exports from ModuleB * available to an NgModule that imports ModuleA. * * ### Example * * The following example exports the `NgFor` directive from CommonModule. * * ```javascript * @NgModule({ * exports: [NgFor] * }) * class CommonModule { * } * ``` */ exports?: Array<Type<any> | any[]>; /** * The set of components to compile when this NgModule is defined, * so that they can be dynamically loaded into the view. * * For each component listed here, Angular creates a `ComponentFactory` * and stores it in the `ComponentFactoryResolver`. * * Angular automatically adds components in the module's bootstrap * and route definitions into the `entryComponents` list. Use this * option to add components that are bootstrapped * using one of the imperative techniques, such as `ViewContainerRef.createComponent()`. * * @see [Entry Components](guide/entry-components) * @deprecated * Since 9.0.0. With Ivy, this property is no longer necessary. * (You may need to keep these if building a library that will be consumed by a View Engine * application.) */ entryComponents?: Array<Type<any> | any[]>; /** * The set of components that are bootstrapped when * this module is bootstrapped. The components listed here * are automatically added to `entryComponents`. */ bootstrap?: Array<Type<any> | any[]>; /** * The set of schemas that declare elements to be allowed in the NgModule. * Elements and properties that are neither Angular components nor directives * must be declared in a schema. * * Allowed value are `NO_ERRORS_SCHEMA` and `CUSTOM_ELEMENTS_SCHEMA`. * * @security When using one of `NO_ERRORS_SCHEMA` or `CUSTOM_ELEMENTS_SCHEMA` * you must ensure that allowed elements and properties securely escape inputs. */ schemas?: Array<SchemaMetadata | any[]>; /** * A name or path that uniquely identifies this NgModule in `getModuleFactory`. * If left `undefined`, the NgModule is not registered with * `getModuleFactory`. */ id?: string; /** * When present, this module is ignored by the AOT compiler. * It remains in distributed code, and the JIT compiler attempts to compile it * at run time, in the browser. * To ensure the correct behavior, the app must import `@angular/compiler`. */ jit?: true; } |
留言
張貼留言