精华内容
下载资源
问答
  • 主要介绍了jQuery实现的简单日历组件定义与用法,结合实例形式详细分析了基于jQuery扩展实现日历功能的相关操作技巧,需要的朋友可以参考下
  • 主要介绍了vue组件定义,全局、局部组件,配合模板及动态组件功能,结合实例形式分析了vue.js中组件的定义、全局组件、局部组件、配合模板组件及动态组件的相关使用方法与操作注意事项,需要的朋友可以参考下
  • 主要介绍了angular基于ng-alain定义自己的select组件示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了基于datepicker定义自己的angular时间组件,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Htc组件一个简单示例

    2009-03-16 09:42:16
    Htc组件一个简单示例.通过自定义的Blank来自定义了一个Htc组件。该示例对于如何通过Htc来扩展、简化Web开发提供一些参考。
  • QQ技术交流群173683866 526474645 欢迎加入交流讨论,打广告的一律飞机票 ...3.父组件在子组件上监听emit定义的事件名称并绑定自身的函数,在函数的参数中接收子组件传递的参数。 效果图: 实现代码: &...

    QQ技术交流群 173683866 526474645 欢迎加入交流讨论,打广告的一律飞机票

    Vue子组件给父组件传值 需要使用自定义事件

    流程:

    1.子组件创建并监听自定义事件,

    2.在事件函数里面执行emit函数,通过emit把想传的值传给父组件

    3.父组件在子组件上监听emit定义的事件名称并绑定自身的函数,在函数的参数中接收子组件传递的参数。

    效果图:

    实现代码:

    <!DOCTYPE html>
    <html>
    
    	<head>
    		<meta charset="utf-8">
    		<title>Vue 父组件和子组件相互传值demo</title>
    		<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0" />
    		<script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js"></script>
    	</head>
    
    	<body>
    		<div id="app">
    			<div id="counter-event-example">
    				<p>{{ total }}</p>
    
    				<!--这里使用了两个子组件,因为子组件的data是函数,所以它们的值互不影响-->
    				<!--父组件在使用子组件的地方直接用 v-on 来监听子组件触发的事件。-->
    				<button-counter v-bind:idx="1" v-on:increment="appAddCounter"></button-counter>
    				<button-counter v-bind:idx="2" v-on:increment="appAddCounter"></button-counter>
    			</div>
    		</div>
    
    		<script>
    			Vue.component('button-counter', {
    				//1.使用 $on(eventName)监听事件
    				template: '<button v-on:click="addCounter">第{{idx}}个子组件: {{ counter }}</button>',
    				props:['idx'],
    				data: function() {
    					return {
    						counter: 0
    					}
    				},
    				methods: {
    					//子组件的自定义事件  
    					addCounter: function() {
    						this.counter += 1;
    						var str ='我是第'+this.idx+'个子组件,我的值为:'+this.counter;
    						//2.使用 $emit(eventName,obj) 触发事件   
    						//increment: 是父组件指定的传数据绑定的函数,str: 子组件给父组件传递的数据
    						this.$emit('increment',str);
    					}                                                                                                                                                            
    				},
    			})
    			new Vue({
    				el: '#counter-event-example',
    				data: {
    					total: 0
    				},
    				methods: {
    					appAddCounter: function(e) {
    						console.log('子组件传的值:',e)
    						this.total += 1
    					}
    				}
    			})
    		</script>
    	</body>
    
    </html>

     

    展开全文
  • Android组件化开发简单示例

    千次阅读 多人点赞 2020-11-21 15:01:52
    一、组件化初始模型 ...2、app外壳main组件是我们app的必备组成部分,一起构成了可对外发布的完整app,其他组件可以集成进来,也可以不集成进来,只会增加或者减少我们app的功能,但不影响我们app的最终.

    Android组件化示例代码github地址:https://github.com/respost/ModuleDemo

    一、组件化初始模型

    1、通过一个简单的android项目初始架构图来了解组件化,如下图:

    打个生动的比喻,把我们的APP当成一个电脑主机,那么app外壳就是主机外壳,main组件就是主板,其他各个组件就类似于硬盘、网卡、显卡之类的东西,各个组件连接到主板上,然后再安装到主机壳中,对外展示为一个完整的电脑主机。 

    2、app外壳和main组件是我们app的必备组成部分,一起构成了可对外发布的完整app,其他组件可以集成进来,也可以不集成进来,只会增加或者减少我们app的功能,但不影响我们app的最终发布。

    二、创建Module模块(组件)

    在我们的实际项目中,组件展示出来的效果大概是这样的:

    1、我们开始创建Module模块,项目的APP上右键 → New  → Module

    2、选择 Android Library  →  Next

    3、 输入模块名称   →  Finish

    三、组件的build.gradle文件说明

    1、通过以上Module模块的创建,包括main组件在内,一共有5个组件,所以对应的有5个组件build.gradle文件,如下图:

    2、 main组件的gradle文件中,apply plugin使用的是com.android.application

    3、其他业务模块(组件A、组件B、组件C、common组件等),apply plugin使用的是com.android.library 

    四、组件集成

    各个组件都建立完成之后,接下来可以把组件集成到main组件中,集成非常简单,只需在main组件的gradle文件中添加dependencies{}配置,添加如下语句:

    dependencies {
         ...
    
        //集成组件A
        implementation project(':modulea')
        //集成组件B
        implementation project(':moduleb')
        //集成组件C
        implementation project(':modulec')
    }

    如下图: 

    五、组件资源共享

    1、在common组件的build.gradle文件中,添加android 配置,如下:

    android {
    
        //省略前面的代码...
    
        repositories {
            flatDir {
                dirs 'libs'
            }
        }
    }

    在各个需要调用公共common组件的组件build.gradle文件中,也添加android 配置,如下:

    android {
       
         //省略前面的代码..
    
        repositories {
            flatDir {
                dirs '../common/libs/', 'libs'
            }
        }
    
    }

    2、common组件里引入各种类库的时候必须用api,而不是用implementation,原因:

    implementation编译的依赖只作用于当前的module,即common组件模块中使用implementation编译的三方库只对common模块起作用,main组件模块中无法使用该三方库。

     

    3、关于组件资源共享,举个简单示例:例如图片都是存放到公共的common组件的res里,那么如何在组件A、组件B、组件C里使用呢?

    使用方法如下:

    • 打开各组件的build.gradle文件,在dependencies{}里添加如下代码即可:
    dependencies {
        
        ...
    
        implementation project(':common')
    }
    • 如此一来,就能在组件A里调用common组件的图片资源了

    4、同样的道理, 组件A、 组件B、 组件C的颜色代码也可以直接调用公共common组件里colors.xml的代码

    5、我们可以把其他第三方库、自定义view、工具类、公用资源都放进公共common组件里,也就是说组件A、组件B、组件C里build.gradle所引入的类库,都可以放到common组件里的dependencies{}里

    6、所以各个业务组件里面的build.gradle文件的dependencies{}配置简化后,就变成了下面这样:

    7、通过以上解说,大家应该都明白了吧,图片、xml这些(value目录下的各种xml文件),都可以放到公共common组件里,然后再被其他组件引用。对于全局共用的style.xml文件,我们更应该把它放在common组件中,例如我们的项目theme,本来是放在main组件的style里面,我们可以把它移到common中,这样其他组件调试时,作为一个单独的项目,也能和主项目有一样的主题。总而言之,所有你认为可以被各个组件共享的资源,都可以放在common组件中。

    六、往组件里添加Fragment

    1、以组件A为例,在组件A里添加一个包fragment

    2、在fragment包右键   →  New   →  Fragment   →Fragment(Blank)

    3、 填写Fragment碎片名称,勾选创建xml文件,如下:

    4、对应的fragment_module_a.xml文件代码:

    <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <ImageView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:scaleType="centerCrop"
            android:src="@drawable/a" />
    
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:padding="5dp"
            android:text="组件A"
            android:background="@color/green"
            android:textColor="@android:color/white"
            android:textSize="24dp" />
    
    </FrameLayout>

    5、其他组件也类似组件A一样,创建一个Fragment碎片,然后添加不同的背景图片即可。

    6、main组件里添加导航和Fragment容器,main组件里activity_main.xml的代码如下:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/container"
        android:orientation="vertical">
    
        <FrameLayout
            android:id="@+id/content"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1">
        </FrameLayout>
    
        <com.google.android.material.bottomnavigation.BottomNavigationView
            android:id="@+id/navigation"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="bottom"
            android:background="?android:attr/windowBackground"
            app:menu="@menu/navigation" />
    </LinearLayout>

    7、res下创建一个menu目录,里面添加一个navigation.xml文件,代码如下:

    <?xml version="1.0" encoding="utf-8"?>
    <menu xmlns:android="http://schemas.android.com/apk/res/android">
        <item
            android:id="@+id/navigation_a"
            android:icon="@drawable/home"
            android:title="组件A" />
        <item
            android:id="@+id/navigation_b"
            android:icon="@drawable/video"
            android:title="组件B" />
        <item
            android:id="@+id/navigation_c"
            android:icon="@drawable/me"
            android:title="组件C" />
    </menu>
    

     navigation.xml里调用的icon图片分别放到drawable和drawable-24目录里,最终主APP的MainActivity界面如下图:

    8、MainActivity.java的代码如下:

    package net.zy13.module.demo;
    
    import androidx.annotation.NonNull;
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.fragment.app.Fragment;
    import androidx.fragment.app.FragmentTransaction;
    
    import android.os.Bundle;
    import android.view.MenuItem;
    
    import com.google.android.material.bottomnavigation.BottomNavigationView;
    
    import net.zy13.module.modulea.fragment.ModuleAFragment;
    import net.zy13.module.moduleb.fragment.ModuleBFragment;
    import net.zy13.module.modulec.fragment.ModuleCFragment;
    
    public class MainActivity extends AppCompatActivity implements BottomNavigationView.OnNavigationItemSelectedListener {
    
        //定义碎片集合
        private Fragment[] fragments = new Fragment[3];
        //当前显示的fragment的索引位置
        private int currentIndex = 0;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            initFragment();
            BottomNavigationView navigation = (BottomNavigationView) findViewById(R.id.navigation);
            navigation.setOnNavigationItemSelectedListener(this);
        }
    
        /**
         * 初始化Fragment碎片
         */
        private void initFragment() {
            if (fragments[0] == null) {
                fragments[0] = new ModuleAFragment();
                getSupportFragmentManager().beginTransaction().add(R.id.content, fragments[0], "moduleA").commit();
            } else {
                getSupportFragmentManager().beginTransaction().show(fragments[0]);
            }
        }
    
        /**
         * 导航选择事件
         * @param item
         * @return
         */
        @Override
        public boolean onNavigationItemSelected(@NonNull MenuItem item) {
            switch (item.getItemId()) {
                case R.id.navigation_a:
                    if (currentIndex == 0) return true;//如果已经是当前的fragment,不用切换
                    FragmentTransaction transition0 = getSupportFragmentManager().beginTransaction();
                    hideAndShow(0,transition0);
                    return true;
    
                case R.id.navigation_b:
                    if (currentIndex == 1) return true;//如果已经是当前的fragment,不用切换
                    FragmentTransaction transition1 = getSupportFragmentManager().beginTransaction();
                    if (fragments[1] == null) {
                        fragments[1] = new ModuleBFragment();
                        transition1.add(R.id.content, fragments[1], "moduleB");
                    }
                    hideAndShow(1,transition1);
                    return true;
    
                case R.id.navigation_c:
                    if (currentIndex == 2) return true;//如果已经是当前的fragment,不用切换
                    FragmentTransaction transition2 = getSupportFragmentManager().beginTransaction();
                    if (fragments[2] == null) {
                        fragments[2] = new ModuleCFragment();
                        transition2.add(R.id.content, fragments[2], "modulec");
                    }
                    hideAndShow(2,transition2);
                    return true;
            }
            return false;
        }
    
        /**
         * 除了指定的fragment不hide,其他fragment全hide
         * @param expectIndex 指定的fragment在fragments中的位置
         * @param transition
         */
        private void hideAndShow(int expectIndex,FragmentTransaction transition) {
            for (int i = 0; i < fragments.length; i++) {
                if (i != expectIndex && fragments[i] != null) {
                    transition.hide(fragments[i]);
                }
            }
            transition.show(fragments[expectIndex]);
            transition.commit();
            currentIndex = expectIndex;
        }
    }
    

    9、Run运行项目,最终效果如下图,点击导航,可以切换到对应的组件上:

    七、各个组件单独开发(测试)

     前面我们把各个组件集成到main组件中,现在我们把组件拆分出来,单独开发,开发测试完成后,再把组件集成到main组件中,最后发布。组件单独出来开发的方法就是:在build.gradle文件中,把apply plugin: 'com.android.library',改成apply plugin: 'com.android.application',也就是把其library模式改为application模式,因为只有application才可以单独运行,library必须依靠application才能运行。

    那么问题来了?

    组件单独开发时,我们需要改build.gradle的apply plugin模式,等要集成到main组件时,又得改回来,如果这样子手工去改,组件一多,修改起来比较麻烦,也不优雅。优雅的解决办法就是设置一个开关,打开时,就是application模式,可以单独开发;关闭时,就是library模式,可以集成到main组件中。现在按我下面的步骤来实现:

    1、在项目根目录下,有一个build.gradle文件,在这个文件最末尾添加一个ext {}配置,然后在ext配置里设定一个常量isDebug,值设为true

    ext {
        /**
         * 组件调试模式
         * isDebug = true 是组件模块,说明是单独的App
         * isDebug = false是集成模式,说明是依赖Lib
         * 每次更改“isDebug”的值后,需要点击 "Sync Project" 按钮
         *
         */
        isDebug = true
    }

     

    2、build.gradle里设置了isDebug常量后,我们项目中的其他build.gradle文件都可以把这个常量读取出来,所以我们可以在其他组件的build.gradle文件中,读取该常量的值,动态设置apply plugin,代码如下:

    if(isDebug){
        apply plugin: 'com.android.application'
    }else{
        apply plugin: 'com.android.library'
    }

    3、这样子设置之后,当我们需要切换模式时,只需要修改项目根目录下build.gradle文件中isDebug常量的值,修改完成之后,点击Project sync按钮同步一下即可。如果有报错,那么还有个地方需要修改一下,就是main组件的build.gradle文件,我们把module的模式改成了application,main组件就不能引入application,引入的话就会报错,所以当是debug调试模式时,这里就不引入该组件,以免报错。所以在集成组件前,要先判断是什么模式,如下图:

    4、接下来还得修改 AndroidManifest.xml,当把一个module设置为application时,AndroidManifest.xml需要包含一个app所需要的属性,例如app的icon、theme、launch Activity这些属性设置,而当module为library时,这些属性就都不需要用到,所以当我们处于不同模式时,AndroidManifest.xml文件的配置也得不同。方法如下:

    (1)、Android目录模式切换到Project目录模式

    (2)、 在各个组件的src文件夹中新创建一个debug目录,再把我们用于debug调试的AndroidManifest.xml文件放进去

    (3)、调试用的AndroidManifest.xml文件可以直接复制manifests目录里的,然后添加application的基本信息,如下:

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="net.zy13.module.modulea">
        <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">
        </application>
    </manifest>

    以上内容会有很多错误提示,其实提示的无非就是资源找不到,既然前面我们已经创建了公共的common组件,那么我们只需要把main组件中相应的资源移动到common组件中就可以了。

    5、接下来在各个组件的build.gradle文件中,指定不同模式下使用的AndroidManifest.xml文件,在android {}里添加如下代码:

    sourceSets {
            main {
                if (isDebug) {
                    manifest.srcFile 'src/debug/AndroidManifest.xml'
                }else{
                    manifest.srcFile 'src/main/AndroidManifest.xml'
                    //集成开发模式下排除debug文件夹中的所有Java文件
                    java {
                        exclude 'debug/**'
                    }
                }
            }
    }

    6、以上设置完成,并且sync project(同步项目)之后,各个组件会是这样的目录结构:

    7、在各个组件里创建一个用于调试启动的MainActivity活动,然后把fragment加载到activity_main.xml里,所对应的activity_main.xml布局文件如下:

    <?xml version="1.0" encoding="utf-8"?>
    <fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="net.zy13.module.modulea.fragment.ModuleAFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    </fragment>

    8、添加MainActivity活动后,我们还需要手动设置该活动为入口,打开src/debug/目录下的AndroidManifest.xml文件,修改MainActivity的配置如下:

    <activity
        android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    9、以上步骤完成之后,组件就可以单独作为一个app来开发测试了,android studio的运行app里面,同时多了几个可运行的项目,如下图:

    八、统一项目版本号

    各个组件的build.gradle文件中,有很多版本号。为了避免每次修改都得同时修改多份build.gradle文件,也避免不同的组件使用的版本不一样,导致冲突,所以我们可以把这些版本号统一管理起来,方法如下:

    1、在项目根目录下的build.gradle文件中,定义版本号常量

    ext {
        /**
         * 组件调试模式
         * isDebug = true 是组件模块,说明是单独的App
         * isDebug = false是集成模式,说明是依赖Lib
         * 每次更改“isDebug”的值后,需要点击 "Sync Project" 按钮
         *
         */
        isDebug = true
        //版本号
        android = [
                compileSdkVersion: 30,
                buildToolsVersion: "30.0.0",
                minSdkVersion    : 15,
                targetSdkVersion : 30,
                versionCode      : 1,
                versionName      : "1.0"
        ]
    }

    2、然后在各个组件的build.gradle文件中,做这样的修改:

    android {
        compileSdkVersion rootProject.ext.android.compileSdkVersion
        buildToolsVersion rootProject.ext.android.buildToolsVersion
        defaultConfig {
            minSdkVersion rootProject.ext.android.minSdkVersion
            targetSdkVersion rootProject.ext.android.targetSdkVersion
            versionCode rootProject.ext.android.versionCode
            versionName rootProject.ext.android.versionName
        }
    }

    九、使用路由实现组件之间的通信 

    通过前面的学习,我们已经知道组件可以拆分了,但是当他们集成到main组件中时,还是需要一定的通信,例如业务A需要调用到业务B的一个页面,甚至进行传参。但是在“组件化”模式下,业务A和业务B是完全分开的,在业务A的认知里,根本就不存在业务B,也就没办法直接调用。当然,如果要业务A与业务B可以直接通信,互相引入就可以,但是这样的话,项目耦合性太高,架构也混乱,会把“组件化”的所有优点都一一撇掉,所以我们应该用另外一种方式来处理。

    这里需要引入一个概念:路由”,就如我们实际访问网络一样,我们电脑发送的请求都经过路由器转发,在“组件化”中,我们也可以设置这么一个中转站,来统一处理不同组件之间的调用关系。关于路由的用法,后面会补充,这里先用最简单的方法,来实现组件之间的调用(页面跳转),代码如下:

    try {
        Class c= Class.forName("net.zy13.module.modulea.MainActivity");
        Intent intent = new Intent(context,c);
        startActivity(intent);
    } catch (ClassNotFoundException e) {
        Log.e("组件","组件未集成,无法跳转");
    }

    以上代码是通过完整的类名来进行跳转,在debug模式下,调用其他组件时,找不到对应组件,不会直接报错,只是提示“未集成,无法跳转”。我们可以把这个方法写成一个工具类,放在common组件中,方法如下:

    1、在common组件里创建一个工具类PageUtils.java,代码如下:

    import android.content.Context;
    import android.content.Intent;
    import android.util.Log;
    
    /**
     * @author 安阳 QQ:15577969
     * @version 1.0
     * @team 美奇软件开发工作室
     * @date 2020/11/12 11:55
     */
    public class PageUtils {
        /**
         * 页面跳转
         * @param context
         * @param className
         */
        public static void jump(Context context, String className){
            try {
                Class c = Class.forName(className);
                Intent intent = new Intent(context,c);
                context.startActivity(intent);
            } catch (ClassNotFoundException e) {
                Log.e("组件","未集成,无法跳转");
            }
        }
    
        /**
         * 页面跳转,可以传参,参数放在intent中,所以需要传入一个intent
         * @param context
         * @param className
         * @param intent
         */
        public static void jump(Context context,String className,Intent intent){
            try {
                Class c = Class.forName(className);
                intent.setClass(context,c);
                context.startActivity(intent);
            } catch (ClassNotFoundException e) {
                Log.e("组件","未集成,无法跳转");
            }
        }
    }
    

    2、在需要跳转的地方,直接用以下方法调用:

    PageUtils.jump(context,"net.zy13.module.modulea.MainActivity");

    还有一种通信情况,就是其中某个组件的改变会影响到其他组件的改变。例如用户的登陆情况(是否登录),会影响到其他组件中一些控件的显示情况,这个时候我们可以用android的广播机制,或者用EventBus来解决。实际开发中,如果是像这种会影响全局的改变,应该放在公共的common组件之中。用户的登陆情况,是影响全局的存在,那么就可以在common中,定义一个用户单例,其他组件分别拿这个单例去控制其界面的显示,特别是引入databingding之后,操作起来更为方便,具体的实现方式大家可以百度参考其他教程,这里我就不实现了。

    十、android路由框架

    关于路由框架的具体用法,我单独整理成了一篇文章,示例代码也是写在了组件化项目里。

    Android的路由框架用法:https://blog.csdn.net/qq15577969/article/details/109690111

    展开全文
  • 四种组件定义方式都存在以下共性(血泪史) 规则: 1.组件只能有一个根标签 2.记住两个词全局局部 3.组件名称命名中‘-小写字母’相当于大写英文字母(hello-com 相当于 helloCom) 而对于在HTML中自定义组件的时候...
  • 自定义组件我把它分为简单的三个步骤, 1.创建组件 --- 2.编写组件 --- 3.调用,使用组件. 第一步:创建组件 创建一个modal文件夹,里面包含 josn.wxml.wcss.js 四个文件,然后在josn里面添加"component":true (作用是...

    微信小程序开发交流qq群   173683895

       承接微信小程序开发。扫码加微信。

    正文:

    自定义组件我把它分为简单的三个步骤, 1.创建组件 --- 2.编写组件  ---   3.调用,使用组件. 

    第一步:创建组件

    创建一个modal文件夹,里面包含 josn.wxml.wcss.js 四个文件,然后在josn里面添加 "component":true (作用是声明这一组文件为自定义组件)

     

    第二步. 编写组件代码

    在modal.wxml :

     

    <view hidden='{{modalHidden}}'>
      <view class='mask_layer' bindtap='modal_click_Hidden' />
      <view class='modal_box'>
        <view class="title">提示</view>
        <view class='content'>
          <text class='modalMsg'>{{modalMsg}}</text>
        </view>
        <view class='btn'>
          <view bindtap='modal_click_Hidden' class='cancel'>取消</view>
          <view bindtap='Sure' class='Sure'>确定</view>
        </view>
      </view>
    </view>

     

    在modal.wxss:

     

    .mask_layer {
      width: 100%;
      height: 100%;
      position: fixed;
      z-index: 1000;
    left:0;top:0;
      background: #000;
      opacity: 0.5;
      overflow: hidden;
    }
    .modal_box {
      width: 76%;
      overflow: hidden;
      position: fixed;
      top: 50%;
      left: 0;
      z-index: 1001;
      background: #fafafa;
      margin: -150px 12% 0 12%;
      border-radius: 3px;
    }
    
    .title {
      padding: 15px;
      text-align: center;
      background-color: gazure;
    }
    
    .content {
      overflow-y: scroll; /*超出父盒子高度可滚动*/
    }
    
    .btn {
      width: 100%;
      margin-top: 65rpx;
      display: flex;
      flex-direction: row;
      align-items: center;
      justify-content: space-between;
      box-sizing: border-box;
      background-color: white;
    }
    
    .cancel {
      width: 100%;
      padding: 10px;
      text-align: center;
      color: red;
    }
    
    .Sure {
      width: 100%;
      padding: 10px;
      background-color: gainsboro;
      text-align: center;
    }
    
    .modalMsg {
      text-align: center;
      margin-top: 45rpx;
      display: block;
    }

    在modal.js

     

     

    Component({
      properties: {
        modalHidden: {
          type: Boolean,
          value: true
        }, //这里定义了modalHidden属性,属性值可以在组件使用时指定.写法为modal-hidden
        modalMsg: {
          type: String,
          value: ' ',
        }
      },
      data: {
        // 这里是一些组件内部数据
        text: "text",
      },
      methods: {
        // 这里放置自定义方法
        modal_click_Hidden: function () {
          this.setData({
            modalHidden: true,
          })
        },
        // 确定
        Sure: function () {
          console.log(this.data.text)
        }
      }
    })


    第三步, 使用组件

     

    这里我是在 pages/index/index 页面调用 pages/modal/modal 自定义组件

    首先在index.json中进行引用说明, 这里是设置自定义组件的标签名和引用路径

    {
      "usingComponents": {
        "modal": "../modal/modal"
      }
    }

    然后在index.wxml调用组件

    <!-- 调用modal组件 -->
    <modal modal-hidden="{{is_modal_Hidden}}" modal-msg="{{is_modal_Msg}}"/>

    在index.js绑定数据,

    Page({
      data: {
        is_modal_Hidden:false,
        is_modal_Msg:'我是一个自定义组件'
      }
    })

    效果图:



     

    如果需要查看更加详细的文档,可以在官方文档查看, 地址为:  https://mp.weixin.qq.com/debug/wxadoc/dev/framework/custom-component/

     

    展开全文
  • 本文主要跟大家分享了ES6下React组件的写法示例,下面来一起看看详细的介绍: 一:定义React组件 class Hello extends React.Component { render() { return <h1>Hello, {this.props.value}; } } 二:声明prop...
  • 在Angular应用开发中,组件可以说是随处可见的。本篇文章将介绍几种常见的组件通讯场景,也就是让两...先定义两个组件,分别为子组件DemoChildComponent组件DemoParentComponent. 子组件: @Component({ select
  • 本文实例讲述了Vue2.0实现组件之间数据交互通信操作。分享给大家供大家参考,具体如下: Vue2.0组件之间数据交互通信。 Vue2.0废弃了dispatch $broadcast,如何在实现组件之间的数据交互通信?下面是一个...
  • 本机模块本机UI组件的基本示例。 本机UI组件 iOS 子类化RCTViewManager并返回您的本机视图。 // CustomViewManager.swift @objc (RCTCustomViewManager) class RCTCustomViewManager : RCTViewManager { ...
  • Vue:局部注册组件和示例代码

    千次阅读 2019-05-31 17:40:43
    比如,如果你使用一个像 webpack 这样的构建系统,全局注册所有的组件意味着即便你已经不再使用一个组件了,它仍然会被包含在你最终的构建结果中。这造成了用户下载的 JavaScript 的无谓的增加。 在这些情况下,你...

    在Vue教程(参考链接:https://cn.vuejs.org/v2/guide/components-registration.html)中提到,全局注册往往是不够理想的。比如,如果你使用一个像 webpack 这样的构建系统,全局注册所有的组件意味着即便你已经不再使用一个组件了,它仍然会被包含在你最终的构建结果中。这造成了用户下载的 JavaScript 的无谓的增加。

    在这些情况下,你可以通过一个普通的 JavaScript 对象来定义组件:

    var ComponentA = { /* ... */ }
    var ComponentB = { /* ... */ }
    var ComponentC = { /* ... */ }

    然后在 components 选项中定义你想要使用的组件:

    new Vue({
      el: '#app',
      components: {
        'component-a': ComponentA,
        'component-b': ComponentB
      }
    })

    对于 components 对象中的每个属性来说,其属性名就是自定义元素的名字,其属性值就是这个组件的选项对象。

    完整示例代码(Demo.vue):

    <template>
      <div style="margin-top:100px">
        <component-a></component-a>
        <component-b></component-b>
      </div>
    </template>
    
    <script type="text/javascript">
    var ComponentA = {
      template: `<el-input placeholder="在这里输入文本"></el-input>`
    }
    var ComponentB = {
      template: `<el-input placeholder="在这里输入文本"></el-input>`
    }
    
    export default {
      name: 'learn',
      components: {
        'component-a': ComponentA,
        'component-b': ComponentB
      },
      data () {
        return {
        }
      }
    }
    </script>
    
    <style>
    </style>
    

    另外一个示例:

    <template>
      <div style="margin-top:100px">
        <component-a></component-a>
        <component-b></component-b>
      </div>
    </template>
     
    <script type="text/javascript">
    var ComponentA = {
      data () {
        return {
          input: '',
          select: ''
        }
      },
      methods: {
        handleChange (value) {
          console.log(value)
        }
      },
      template: `
      <el-input placeholder="请输入内容" v-model="input" style="width: 600px" class="input-with-select">
        <el-select v-model="select" slot="prepend" placeholder="请选择">
          <el-option label="餐厅名" value="1"></el-option>
          <el-option label="订单号" value="2"></el-option>
          <el-option label="用户电话" value="3"></el-option>
        </el-select>
        <el-button slot="append" icon="el-icon-search"></el-button>
      </el-input>
      `
    }
    var ComponentB = {
      data () {
        return {
          num: 1
        }
      },
      methods: {
        handleChange (value) {
          console.log(value)
        }
      },
      template: `
      <el-input-number v-model="num" @change="handleChange" :min=1 :max=10 label="描述文字">
      </el-input-number>
      `
    }
     
    export default {
      name: 'learn',
      components: {
        'component-a': ComponentA,
        'component-b': ComponentB
      },
      data () {
        return {
          num: 1,
          input: '',
          select: ''
        }
      },
      methods: {
        handleChange (value) {
          alert(value)
        }
      }
    }
    </script>
     
    <style>
    .el-select .el-input {
      width: 130px;
    }
    .input-with-select .el-input-group__prepend {
      background-color: #fff;
    }
    </style>

     

    展开全文
  • 小程序定义了各种各样的组件,它们在...组件定义及属性 1)组件是视图层的基本组成单元 2)组件自带一些功能与微信风格的样式 3)一个组件通常包括开始标签结束标签,属性用来修饰这个组件,内容在两个标签之...
  • 本文实例讲述了vue学习笔记之给组件绑定原生事件操作。分享给大家供大家参考,具体如下: 当在父组件定义一个点击事件,并且在父组件的methods中定义了这个点击事件时,在页面上点击并不会有什么反应。那么该...
  • 主要介绍了Angular 2使用路由自定义弹出组件toast操作,结合实例形式分析了Angular2使用路由操作弹出组件toast相关定义与使用技巧,需要的朋友可以参考下
  • 本文实例讲述了Vue.js实现可排序的表格组件功能。分享给大家供大家参考,具体如下: 我们基于 Vue.js 实现一个可根据某列进行排序的表格组件。 一个表格包含表头数据两部分内容。...把父组件定义的 dat
  • ./client每个客户端组件./client定义了自己的依赖项,包括“本地”(在./client目录中)开发人员创建的公共组件的远程依赖项。 这只是您如何构建应用程序的一个示例。 例如,您可以采用更传统的方法./models 、 ...
  • 组件定义及属性 1)组件是视图层的基本组成单元 2)组件自带一些功能与微信风格的样式 3)一个组件通常包括开始标签结束标签,属性用来修饰这个组件,内容在两个标签之内 按类型可以将组件划分为七大类:视图容器...
  • 使用一个选项数组,您可以定义后端 Aesop 故事引擎将使用的设置,如果用户激活了套索,则可以在前端编辑您的组件。 如果您可以使用 WordPress 创建短代码,那么您就可以为 Aesop Story Engine Lasso 创建附加...
  • 像alert、modal等组件每个页面引入就得重复引入,并不像element那样可以通过this.$xxx来调用,那么问题来了,如何通过this.$xxx来调用起我们定义组件或对我们所使用的UI框架的组件呢。 以bootstrap-vue中的Alert...
  • Laravel 如何在blade文件中使用Vue组件,具体代码详情请看下文: 1. 安装laravel/ui依赖包 composer require laravel/ui ...ExampleComponent.vue文件是单个文件Vue组件示例,该组件在同一文件中定义其JavaScrip
  • 主要介绍了微信分享通用组件,用于微信浏览器内浏览网页的分享信息定义,需要的朋友可以参考下
  • Camel自定义组件示例

    千次阅读 2014-09-07 21:11:23
    要想在Camel中自定义组件,就要对Camel中关键概念进行理解,了解Camel中路由的构建过程与启动过程,在前面的文章中已经有相关的叙述。 这里就给出一个自定义组件的例子。该例子还是以文件轮询为主题,下面是具体...
  • 表示在Angular中使用标准Web组件示例。 要创建Web组件,您应该在the app.module.ts定义它。 AppModule的构造函数中提供的AppModule 。 web-component.js文件用于将所有脚本连接为单个文件,并将其移动到单独的...
  • 小程序自定义组件 | dialog源码&示例

    千次阅读 2019-12-29 16:11:21
    小程序自定义组件与父子组件之间通信

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 213,456
精华内容 85,382
关键字:

组件的定义和发布示例