GVKun编程网logo

Vue学习笔记（一）数据绑定（vue 数据绑定）

22

此处将为大家介绍关于Vue学习笔记的详细内容，并且为您解答有关一数据绑定的相关问题，此外，我们还将为您介绍关于Gradle学习笔记（一）、Gradle学习笔记（一）--环境搭建、guice学习笔记（一

此处将为大家介绍关于Vue学习笔记的详细内容，并且为您解答有关一数据绑定的相关问题，此外，我们还将为您介绍关于Gradle学习笔记（一）、Gradle学习笔记（一）--环境搭建、guice学习笔记（一） - 初体验、J2SE学习笔记（一）的有用信息。

本文目录一览：

Vue学习笔记（一）数据绑定（vue 数据绑定）

Vue学习笔记（一）数据绑定（vue 数据绑定）

Vue学习笔记（一）数据绑定

一、初识Vue

1.MVVM模式

Model-View-View-Model模式是由经典的软件架构MVC衍生来的。当View（视图层）变化时，会自动更新ViewModel（视图模型），反之亦然。View和ViewModel之间通过双向绑定建立联系。

2.如何使用Vue.js

1）可直接通过script加载CDN文件

<!--自动识别最新稳定版本的Vue.js-->
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>

2）使用Vue单文件的形式配合webpack使用

二、数据绑定

1.实例与数据

Vue.js应用的创建很简单，通过构造函数Vue就可以创建一个Vue的根实例，并启动Vue应用：

<div id="app">
        {{info}}
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <script>
        var app = new Vue({
            el: ''#app'',
            data: {
                info: ''hello world''
            }
        })
    </script>
  • 变量app代表Vue实例。
  • 选项el用于指定一个页面中已存在的DOM元素来挂载Vue实例，它可以是HTMLElement，也可以是CSS选择器。挂载成功后，我们可以通过app.$el来访问元素。Vue提供了很多常用的实例属性与方法都以$开头。
  • {{info}}插值，将数据显示出来

2.生命周期

  • created：实例创建完成后调用，此阶段完成了数据观测等，但尚未挂载，$el还不可用。需要初始化处理一些数据时会比较有用。
  • mounted：el挂载到实例上后调用，一般我们的第一个业务逻辑会在这里开始。
  • beforeDestroy：实例销毁之前调用，主要解绑一些使用addEventListener监听的事件等。

这些钩子与el和data类似，也是作为选项写入Vue实例内，并且钩子的this指向的是调用它的Vue实例。

<div id="app">
        {{info}}
    </div>    
    <script>
        var app = new Vue({
            el: ''#app'',
            data: {
                info: ''hello world''
            },
            created: function() {
                console.log(this.info);
            },
            mounted: function() {
                console.log(this.$el);
            }
        })
    </script>

3.插值与表达式

“{{}}”是最基本的文本插值方法，它会自动将我们双向绑定的数据实时显示出来。例如上面的info，通过任何方法修改数据info，大括号的内容都会被实时替换。

v-html：如果有的时候想输出HTML，而不是将数据解释后的文本，可以使用它。例如下面代码：

<div id="app">
        {{info}}{{link}}
        <span v-html="link"></span>
    </div>
    <script>
        var app = new Vue({
            el: ''#app'',
            data: {
                info: ''hello world'',
                link: ''<a href="#">超链接</a>''

            },
            created: function() {
                console.log(this.info);
            },
            mounted: function() {
                console.log(this.$el);
            }
        })
    </script>

link的内容将会被渲染成一个a标签，而不是纯文本。这里需要注意，如果将用户产生的内容使用v-html输出后，有可能导致XSS攻击。

在{{}}中，除了简单的绑定属性外，还可以使用Js表达式进行简单的运算。

{{number/10}}
{{isOK?''确定'' : ''b取消''}}
{{text.split('','').reverse().join('','')}}

4.过滤器

Vue支持在{{}}插值的尾部添加一个管道符“(|)”对数据进行过滤，经常用于格式化文本，比如字母全部大写、货币千位使用逗号分隔等。过滤的规则是自定义的，通过给Vue实例添加选项filters来设置。

<div id="app1">
        <span>当前时间:{{date|formatDate}}</span>
    </div>
    <script>
        //在月份、日期、小时等于小于10时前面补0
        var padDate = function(value) {
            return value < 10 ? ''0'' + value : value;
        };
        var app1 = new Vue({
            el: ''#app1'',
            data: {
                date: new Date()
            },
            filters: {
                formatDate: function(value) {
                    //value是需要过滤的数据
                    var date = new Date(value);
                    var year = date.getFullYear();
                    var month = padDate(date.getMonth() + 1);
                    var day = padDate(date.getDate());
                    var hours = padDate(date.getHours());
                    var minutes = padDate(date.getMinutes());
                    var seconds = padDate(date.getSeconds());
                    return year + ''-'' + month + ''-'' + day + '' '' + hours + '':'' + minutes + '':'' + seconds;
                }
            },
            mounted: function() {
                var _this = this;
                this.timer = setInterval(function() {
                    _this.date = new Date(); //修改数据date
                })
            },
            beforeDestroy: function() {
                if (this.timer) {
                    clearInterval(this.timer);
                }
            }
        })

过滤器也可以串联，而且可以接收参数

{{message|filterA|filterB}} 串联

{{message|filterA(''arg1'',''arg2'')}} 接收参数

三、指令与事件

指令是Vue模板中最常用的一项功能，它带有前缀v-，比如v-if、v-html、v-pre等。指令的主要职责就是当其表达式的值改变时，相应地将某些行为应用到DOM上。

1.v-if：

<div id="app">
        <p v-if="isShow">显示这段文本</p>
    </div>

当数据isShow的值为true时，p元素会被插入，为false时则会被移除。数据驱动DOM是Vue的核心理念，所以不到万不得已时不要主动操作DOM，你只需要维护好数据，DOM的事Vue会帮你优雅的处理。

2.v-bind

v-bind的基本用途是动态更新HTML元素上的属性。如id、class等。

3.v-on

它用来绑定事件监听器。

四、语法糖

是指在不影响功能的情况下，添加某种方法实现同样的效果，从而方便程序开发。

v-bind可以省略v-bind，用冒号":"代替。

v-on可以活力v-on，可以直接用“@”来缩写。

五、计算属性

模板内的表达式常用于简单的运算，当其过长或逻辑复杂时，会难以维护，计算属性就是解决这一问题的。

所有的计算属性都以函数的形式写在Vue实例内的computed选项内，最终返回计算后的结果。

//输出九九乘法表
<div id="app">
        <p>{{result}}</p>
        <p v-html=''computedResult''></p>
    </div>
    <script>
        var app = new Vue({
            el: ''#app'',
            data: {
                result: ''输出九九乘法表''
            },
            computed: {
                computedResult: function() {
                    var str = '''';
                    for (var i = 1; i < 9; i++) {
                        for (var j = 1; j <= i; j++) {
                            str = str + i + "*" + j + "=" + i * j + "&nbsp;&nbsp;&nbsp;&nbsp;";
                        }
                        str = str + "</br>";
                    }
                    return str;
                }
            }
        })
    </script>

在一个计算属性里可以完成各种复杂的逻辑，包括运算、函数调用等，只要最终返回一个结果就可以。计算属性还可以依赖多个Vue实例的数据，只要其中任何一数据变化，计算属性就会重新执行，视图也会更新。

1.购物车总值计算实例

以下实例，计算购物车中的总价

<div id="app">
        总价：{{prices}}
    </div>
    <script>
        var app = new Vue({
            el: ''#app'',
            data: {
                goods1: [{
                    name: "三星32显示器",
                    price: 1480,
                    count: 2
                }, {
                    name: "飞利浦32显示器",
                    price: 1680,
                    count: 2
                }],
                goods2: [{
                    name: "AOC32曲面显示器",
                    price: 1250,
                    count: 2
                }, {
                    name: "长城曲面显示器",
                    price: 1150,
                    count: 2
                }]
            },
            computed: {
                prices: function() {
                    var prices = 0;
                    for (var i = 0; i < this.goods1.length; i++) {
                        prices = prices + this.goods1[i].price * this.goods1[i].count;
                    }
                    for (var i = 0; i < this.goods2.length; i++) {
                        prices = prices + this.goods2[i].price * this.goods2[i].count;
                    }
                    return prices;
                }
            }
        })
    </script>

每一个计算属性都包含一个getter和一个setter，上面的示例都是计算属性的默认用法，只是利用了getter来读取。当需要时，也可以提供一个setter函数，当手动修改计算属性的值就像修改一个普通数据那样时，就会触发setter函数，执行一些自定义的操作。

绝大多数情况下，我们只会用默认的getter方法来读取一个计算属性，在业务中很少用到setter，所以在声明一个计算属性时，可以直接使用默认的写法，不必将getter和setter都声明。

计算属性除了上述简单的文本插值外，还经常用于动态地设置元素的样式名称class和内联样式style。当使用组件时，计算属性也经常用来动态传递props。

计算属性一是可以依赖其他计算属性，二是不仅可以依赖当前Vue实例的数据，还可以依赖其他实例的数据。

2.计算属性缓存

上面的例子中，使用methods的方法也可以实现相同的效果，但它与计算属性还是不同的。

计算属性是基于它的缓存的。一个计算属性所依赖的数据发生变化时，它才会重新取值，所以它所依赖的数据不发生变化，计算属性也就不更新。

六、v-bind及class与style绑定

v-bind的主要用法是动态更新HTML元素上的属性。

1.绑定class的几种方式

  • 对象语法
<divid="app1">
        <button @click="changeClass">切换class</button>
        <p :>这是一段文本内容</p>
    </div>

    <script>
        var app1 = new Vue({
            el: ''#app1'',
            data: {
                isActive: true,
            },
            methods: {
                changeClass: function() {
                    if (this.isActive) {
                        this.isActive = false;
                    } else {
                        this.isActive = true;
                    }
                }
            }
        })
    </script>

对象中也可以传入多个属性，来动态切换class。另外，:class可以与普通class共存。

<div:></div>

当:class的表达式过长或逻辑复杂时，还可以绑定一个计算属性，一般当条件多于两个时，都可以使用data或computed。除了计算属性，你也可以直接绑定一个Object类型的数据，或者使用类似计算属性的methods。

  • 数组语法

当需要应用多个class时，可以使用数组语法，给:class绑定一个数组，应用一个class列表；

< p   :class = "[isActive,isArror]" > 数组语法 </ p >

也可以使用三元表达式来根据条件切换class

<p:></p>

  • 在组件上使用

如果直接在自定义组件上使用class或:class，样式规则会直接应用到这个组件的根元素上。

2.绑定内联样式

使用v-bind:style可以给元素绑定内联样式，方法与:class类似，也有对象语法和数组语法，

Gradle学习笔记（一）

Gradle学习笔记（一）

前言：我们常用的项目搭建工具使用maven，但是查看各种源码文件的时候发现他们构建工具使用的是gradle，为了更好的理解源码，gradle也是必学之一的了。这里做一次总结。

gradle英式音标：[ɡreɪdl] 美式音标：[ɡredl]

一、介绍和安装

Gradle是基于Groovy语言的项目自动化建构工具，在使用Gradle之前常用的构建工具有Ant和Maven，使用这些工具我们可以用来管理项目依赖，打包，部署和发布等。使用Gradle我们将需要的构建逻辑写入到build.gradle文件中，方便查看和复用。

下载地址：Gradle | Releases

 笔者当时下的是6.2.2

添加环境变量 

 

验证安装是否成功

 

Gradle的配置

可能有很多人在纠结这个 Gradle 能不能像 maven 一样手动修改本地仓库，答案当然是肯定的，而且很简单，只需要在环境变量里面做个配置即可如下图:

 

 笔者让gradle仓库和maven的在一起。

Gradle学习笔记（一）--环境搭建

Gradle学习笔记（一）--环境搭建

一、环境搭建

1、下载gradle

http://gradle.org

2、配置环境变量

GRADLE_HOME E:\gradle-2.11

3、测试配置

gradle -version

打印出GRADLE 2.11表示配置成功

二、Eclipse中插件安装

1、在Eclipse Marketplace搜索gradle，安装buildship gradle

Buildship Gradle Integration 1.0

2、安装完成后，重启Eclipse，在新建项目菜单中就有Gradle项目了

guice学习笔记（一） - 初体验

guice学习笔记（一） - 初体验

guice初体验

guice是Google开源的轻量级依赖注入框架。

maven依赖

        <dependency>
            <groupId>com.google.inject</groupId>
            <artifactId>guice</artifactId>
            <version>4.0</version>
        </dependency>

        <dependency>
            <groupId>com.google.inject.extensions</groupId>
            <artifactId>guice-multibindings</artifactId>
            <version>4.0</version>
        </dependency>

第一个demo

HelloPrinter.java

import javax.inject.Singleton;

@Singleton
public class HelloPrinter {
    public void print() {
        System.out.println("Hello, World");
    }
}

Sample.java

import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

import javax.inject.Singleton;

@Singleton
public class Sample {

    @Inject
    private HelloPrinter printer;

    public void hello() {
        printer.print();
    }

    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}

第二个demo

HelloPrinterInterface.java

import com.google.inject.ImplementedBy;

//@ImplementedBy(SimpleHelloPrinter.class)
public interface HelloPrinterInterface {
    void print();
}


import javax.inject.Singleton;

@Singleton
public class SimpleHelloPrinter implements HelloPrinterInterface {
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}


import javax.inject.Singleton;

@Singleton
public class ComplexHelloPrinter implements HelloPrinterInterface {
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
}

SampleModule.java

import com.google.inject.AbstractModule;
import com.google.inject.multibindings.MapBinder;
import com.google.inject.multibindings.Multibinder;
import com.google.inject.name.Names;

public class SampleModule extends AbstractModule {
    @Override
    protected void configure() {
        //bind(HelloPrinterInterface.class).to(ComplexHelloPrinter.class);
        bind(HelloPrinterInterface.class).annotatedWith(Names.named("simple"))
		.to(SimpleHelloPrinter.class);
        bind(HelloPrinterInterface.class).annotatedWith(Names.named("complex"))
		.to(ComplexHelloPrinter.class);

        Multibinder<HelloPrinterInterface> printerSets = Multibinder
		.newSetBinder(binder(), HelloPrinterInterface.class);
        printerSets.addBinding().to(SimpleHelloPrinter.class);
        printerSets.addBinding().to(ComplexHelloPrinter.class);

        MapBinder<String, HelloPrinterInterface> printerMaps = MapBinder
		.newMapBinder(binder(), String.class, HelloPrinterInterface.class);
        printerMaps.addBinding("simple").to(SimpleHelloPrinter.class);
        printerMaps.addBinding("complex").to(ComplexHelloPrinter.class);
    }
}

Sample.java

import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;

import javax.inject.Singleton;
import java.util.Map;
import java.util.Set;

@Singleton
public class Sample {

    @Inject
    @Named("complex")
    private HelloPrinterInterface printer;

    @Inject
    private Set<HelloPrinterInterface> printerSets;

    @Inject
    private Map<String, HelloPrinterInterface> printerMaps;

    public void hello() {
        printer.print();
    }

    public void helloSet() {
        for (HelloPrinterInterface printer : printerSets) {
            printer.print();
        }
    }

    public void helloMap() {
        for (String key : printerMaps.keySet()) {
            printerMaps.get(key).print();
        }
    }

    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new SampleModule());
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
        sample.helloSet();
        sample.helloMap();
    }

}

参考资料

  • https://github.com/google/guice
  • https://zhuanlan.zhihu.com/p/32299568

J2SE学习笔记（一）

J2SE学习笔记（一）

1、jdk环境变量配置

for win:

假设jdk安装于D:\Java\jdk1.8.0_25下

JAVA_HOME   D:\Java\jdk1.8.0_25

Path        %JAVA_HOME%\BIN

CLASSPATH   .;D:\Java\jdk1.8.0_25\lib\tools.jar;D:\Java\jdk1.8.0_25\lib\dt.jar

for linux:

默认情况下

假设jdk安装于abc用户下，/home/abc/java/jdk1.8.0/

通过home下的.bash_profile配置

PATH=.:$PATH:$HOME/bin:/home/abc/java/jdk1.8.0/bin

导出PATH环境变量

export PATH


部分Linux系统，比如我目前用的Fedora自带的是OpenJDK，故自己安装了龟壳的JDK，可以利用alternatives将龟壳JDK设为默认JDK

具体方法为（来源自网上）：

[root@localhost ~]# /usr/sbin/alternatives --install /usr/bin/java java /usr/java/bin/java 3

其中最后的3是优先度，越小的越优先

[root@localhost ~]# /usr/sbin/alternatives --config java

这里选择龟壳的java作为默认的java

可以通过alternatives --display java来查看配置


开发中可以只设置当前用户的环境变量：

#vi /etc/profile

在最后加上

# Java config
export JAVA_HOME=/usr/java
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH:$HOME/bin


source或重启即可

除了分隔符一个是逗号一个是冒号外，基本和windows一样

其中，环境变量设置win平台以;作为分隔符，linux平台以:作为分隔符


最后，可以通过

java -version
javac -version
javap -version

来检查环境变量是否设置成功


2、java程序的简单编译和运行

编译：javac -d 目录 文件名

运行：java -cp 目录 类名


3、java源文件的命名规则：

a). 文件名必须以.java为后缀

               b). 如果源文件中定义了public修饰的类，主文件名必须与类名相同。

                (一个Java源文件，可以包含多个类定义,但一个Java源文件最多只能包含一个public修饰的类。)

        

4、java代码注释

单行注释 //

        多行注释/*  */

文档注释/** */

@author 作者

@version 版本

@param 参数

@return 返回值

@see 参见

@exception 抛出异常的类型

@throw 抛出异常的类型

javadoc -d 路径 java源文件或包

生成文档注释可以支持html代码，以确保美观


5、java的数据类型——java是强类型语言

a)整型:byte、short、int、long

（1）. 当我们直接给出一个整数值时，它默认是int型，系统绝不会把它当成long处理。

      （2）. 当我们直接给出一个在指定取值范围内的整数时，系统也可把它当成byte、short使用。

      （3）. 如果你系统把一个整数当成long使用，应该在整数后添加l或L。

      10进制 默认

      16进制 Ox或0X开头 0～9、a～f

      8进制 O开头 0~7

      2进制(jdk1.7+) 0b或0B开头 0~1


b)浮点型:float、double

java中默认浮点型是double，除非在结尾加上f，如1.23f

float ：4个字节，32位。大概只能装7～8位有效数字

      double：8个字符，64位。

      浮点型有3个特殊值：

          正无穷大  Infinty    正数除以0，得到无穷大。

            ● 所有正无穷大都相等。

          负无穷大  -Infinity  负数除以0，得到无穷大。

            ● 所有负无穷大都相等。

          非数  NaN :0 除以0， 对负数开方等。

非数与任何数都不相等，包括它自己！


c)字符型:char

Unicode字符集，char占2个字节，16位， 65536种状态。

字符型的值，应该用单引号引起来（双引号引起来的是字符串）

字符型有3种形式：单引号的字符、转移字符、Unicode编码(\uXXXX)


d)布尔型:boolean:true、false


类型转换：

byte → short → int → long → float → double

                        ↗

                      char (0~65535)

                      

6、java运算符

a)算数运算符

b)赋值运算符

c)位运算符

d)逻辑运算符

&&与&的区别何在？

      对于“求与”来说，当第一个操作数已经是false时、结果肯定是false，第二个操作数根本不会影响结果。

          &&，根本不会去计算第二个操作数。

          &， 它依然会去计算第二个操作数。

    ||与|的区别何在？

      对于“求或”来说，当第一个操作数已经是true时、结果肯定是true，第二个操作数根本不会影响结果。

          ||，根本不会去计算第二个操作数。

          |， 它依然会去计算第二个操作数。

e)三目运算符


7、java流程控制

a)顺序

b)分支

if()else if(){}else{}

switch(){case xxx:……;break;……default:XXXX;}

                        （从1.7+，switch控制表达式允许String）

c)循环

for / while

(break、continue)


8、java数组

定义数组时要么指定数组的长度（动态初始化），要么指定数组的初始值(静态初始化)

动态初始化：int[] arr=new int[5];

静态初始化：int[] arr2={1,2,3,4,5};

    int[] arr2=new int[]{1,2,3,4,5};

数组遍历：for(int a : arr){System.out.println(a);}

数组类型的变量，只是一个引用变量。定义数组变量，仅仅只是定义了一个指针。

常见的两个数组异常：

空指针异常(NullPointException)

数组索引越界异常(ArrayIndexOutOfBoundsException)

                Java.util.Arrays类的常用方法：

                 binarySearch() 使用二分搜索法来搜索指定的数组

                 copyOf()   复制指定数组，如副本长度不同，截取或用 初始值(0、null、false) 填充，以使副本具有指定的长度

                 copyOfRange()  将指定数组的指定范围复制到一个新数组

                 equals()   比较数组

                 fill()         用指定的值填充数组

                 sort()         数组排序

                 toString()     返回指定数组内容的字符串表示形式

关于Vue学习笔记和一数据绑定的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Gradle学习笔记（一）、Gradle学习笔记（一）--环境搭建、guice学习笔记（一） - 初体验、J2SE学习笔记（一）等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇java集合学习笔记--list（java list 集合）

下一篇Android学习笔记（十二）：Activity-Spinner（android activity）

相关文章