如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

在 C 语言中
1、char a[10] = {"China"} 中，这个 a 占用多少字节？

答：占用 10 个字节。

解析：上面代码对 a 做了赋值的操作，

a[0]='C' ，a[1]='h' ，a[2]='i' ，a[3]='n' ，a[4]='a' ，a[5]='\0'，a[6]='\0'，a[7]='\0'，a[8]='\0'，a[9]='\0'

所以，它占用的是 10 个字节。

2、如果单指 ”China“ ?

答：共 6 个字节。China 占 5 个字节，最后以 '\0' 结束，占 1 个字节。

在 Java 语言中
1、String s = "China"; 占多少字节？

答：占 5 个字节。

System.out.println(Charset.defaultCharset());//获取ide默认编码类型
String s = new String("China".getBytes());
byte[] b = s.getBytes();
System.out.println("" + b.length);
 以上代码，可以输出 "China" 所占的字节长度为 5

2、String s = "中国"; 占多少字节？

答：如果是 汉字 的情况需要考虑编码。

（1）GBK 编码（ide默认）时，每一个汉字占用 2 个字节，那么中国占 4 个字节。

（2）UTF-8 编码时，每一个汉字占用 3 个字节，那么中国占用 6 个字节。

3、转码问题，GBK 转 UTF-8 时，字节占用会变大吗？反过来呢？

//获取的是 UTF-8编码
System.out.println(Charset.defaultCharset());
String s;
try {
        s = new String("中国".getBytes(),"GBK");
        byte[] b = s.getBytes();
        System.out.println("" + b.length);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
}
如上代码是：UTF-8 转 GBK 编码格式，s 长度从 6 字节变为 9 字节。
s 内容变化：中国 —> 涓浗
因为当前编码是 UTF-8，转码之后变成了 3 个文字，占用 9 个字节。然而，反过来的情况是这样的：

中国 (gbk) —> ?й? (utf-8)
s 长度从 4字节 变成了 4字节，虽然长度没发生改变，但是文字已经改变。这里的 ？ 占用 1 个字节。

蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、 网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

如果说 npm 的大新闻，莫过于之前的 left-pad 撤包事件，event-stream 投毒事件，Ant Design 彩蛋事件。使得很多前端开发者又开始重新思考 npm 生态时候真的存在问题？

今天我们文章的主角是 memwatch，一个用来帮助我们检查 Node.js 是否存在内存泄漏的库，和这个库传奇的一生。

2012 年 02 月 06 日，一位 Mozilla 的工程师 lloyd 创建了这个库，并写了一篇博文“Is My NodeJS Program Leaking?”（我的 Node.js 程序是否存在内存泄漏？）。这个包最初被命名为 gcstats，代码上传到了 github。

6 月 27 日，npm 包改名为 memwatch，发布 0.1.1 版。

7 月 4 日，lloyd 为这个库添加了开源许可协议：WTFPL，发布 0.1.2 版。很多人对这个开源许可协议可能比较陌生，WTFPL 的全称是 Do What The Fuck You Want To Public License，中文译名：你他妈的想干嘛就干嘛公共许可证。也许就是这份协议开启了 memwatch 库不寻常的一生。

2013 年 3 月 14 日，作者 lloyd 提交了最后一次代码，发布了 0.2.2 版本。支持的 Node.js 版本为 0.6.0。随后这个库再也没有更新过。

从作者的博文和推文可以看到，作者在 2014 年离开了 Mozilla。而从作者的 github 动态更可以看出，作者应该是转入了 golang 阵营。

2014 年 6 月 28 日，作者的一位前同事 deepak1556 fork 了这个库，增加了对 Node.js 0.11 的支持，并发起了合并请求。但是作者并没有回复，也没有合并此次请求。此时距离原作者放弃这个库也已经过去一年多了。

2015 年 2 月 7 日，marcominetti 又 fork 了 deepak1556 的库，增加了对 Node.js 0.12 的支持，并向原库发起了合并请求，同样没有得到作者的任何回复。于是 marcominetti 决定自立门户，于是将 memwatch 改名为 memwatch-next 发布到了 npm。

2017 年 1 月 27 日，如同前两位维护者一样，marcominetti 也最终放弃了继续更新这个库。到此时，此库支持的 Node.js 版本为 4、5、6。

2018 年 5 月 6 日，eduardbcom 又 fork 了 marcominetti 的库，增加了 Node.js 9 的支持，并且放弃了对 Node.js 9 以下所有版本的支持。改名为 node-memwatch 并发布到了 npm。随后再也没有更新过代码。

2018 年 7 月 17 日，一位开发者 dyatko 又 fork 了 eduardbcom 的库，增加了对 Node.js 8 的支持，并向原库发起了合并请求，同样没有得到作者的任何回复。

但在此次 pr 的评论中，另一位开发者说，airbnb 也 fork 了 marcominetti 的库，并改名为 @airbnb/node-memwatch 发布到了 npm。

有了大厂接手，也算是这个库最终的归宿吧。


蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、 网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

把项目放在wampserver的www目录下，启动wampserver，并且浏览器打开后手动修改url为localhost

index.js=》getData():

ajax.js以及index。js对它的调用:

ajax的参数：method、data、url都是字符串

index.js =》getData（）=》调用ajax

ajax('GET', 'http://localhost/web/ajax/waterfall2/src/js/getPics.php', addDom, 'cpage=' + num, true)

并且url是localhost下——localhost/web/ajax/waterfall2/src/js/getPics.php

不是直接图片资源地址

图片资源地址写在php中，只管调用就行

data：

ajax调用是data是这样的=》'cpage=' + num

 

测试用的data.txt：

一个数组里有很多对象，每个对象都是一张图片的全部信息，每条信息都是json.stringify格式

所以测试用ajax的callback这样写：

function addDom(data) {
    console.log(JSON.parse(data));
}

这个data不是自己定义的，是xhr.responseText，是接口的数据

这个data是callback的参数

回调函数的data参数和使用方法：

xhr.onreadystatechange = function() {

////////状态改变
        if(xhr.readyState == 4) {
            if(xhr.status == 200) {
                callback(xhr.responseText);

////////满足两个条件时,callback才获取数据成功，才能用数据做些什么


            }else {
                console.log('error');
            }
        }
    }

ajax（）中callback是参数，而callback的定义和对数据的操作通常在ajax（）调用之后

例如:

(1)

ajax('GET', 'http://localhost/web/ajax/waterfall2/src/js/data.txt', addDom, 'cpage=2', true);
function addDom(data) {
    console.log(JSON.parse(data));
}

如此简单明了

(2)

function getData() {
//         if(!flag) {
//             flag = true;
//             ajax('GET', 'http://localhost/web/ajax/waterfall2/src/js/getPics.php', addDom, 'cpage=' + num, true)
//             num++;
//         }
//     }
//     getData();
//     function addDom(data) {

……

}

回来…………

ajax中的data在本例中是字符串'cpage=' + num  或者 'cpage=2'这种

get中作用:

xhr.open(method, url + '?' + data + '&timer=' + timer, flag);

post中作用:

xhr.send(data);

话说回来…………

都是获取数据，data.txt和getPics.php区别:

一个只有第2页的地址，一个是动态获取很多页数据

反正就那么传吧  

而ajax

蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、 网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

前面介绍了Vue中组件的创建方式和data及methods属性，本文我们来做一个Vue组件的切换案例，效果如下:

这个效果相信大家都能搞定，本文希望通过这个案例来加深下组件的使用，

Vue 组件切换案例
基础页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="./lib/vue-2.4.0.js"></script>
</head>
<body>
    <div id="app">

    </div>
    <script>
        var vm = new Vue({
            el: "#app",
            data: {

            },
            methods: {
                
            }
        })
    </script>
</body>
</html>


一、通过v-if控制实现
首先我们通过前面介绍的v-if标签来实现下这种效果

1.创建组件
创建我们需要的两个全局组件，并通过标签使用。

<div id="app">

    <login></login>
    <register ></register>
</div>
<script>

    // 创建登录的组件
    Vue.component("login",{
        template: "<h3>这是一个登录LOGIN组件</h3>"
    })
    // 创建注册的组件
    Vue.component("register",{
        template: "<h3>这是一个注册组件</h3>"
    })

    var vm = new Vue({
        el: "#app",
        data: {

        },
        methods: {
            
        }
    })
</script>

2.控制显示
添加链接标签，通过 v-if 和 v-else 标签来控制显示和隐藏，如下



效果



完整代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="./lib/vue-2.4.0.js"></script>
</head>
<body>
    <div id="app">
        <a href="" @click.prevent="flag=true">登录</a>
        <a href="" @click.prevent="flag=false">注册</a>
        <!--注意： v-if v-else-if v-else 使用^_^ -->
        <login v-if="flag"></login>
        <register v-else></register>
    </div>
    <script>

        // 创建登录的组件
        Vue.component("login",{
            template: "<h3>这是一个登录LOGIN组件</h3>"
        })
        // 创建注册的组件
        Vue.component("register",{
            template: "<h3>这是一个注册组件</h3>"
        })
        var vm = new Vue({
            el: "#app",
            data: {
                flag: false
            },
            methods: {}
        })
    </script>
</body>
</html>

二、通过component标签来实现
除了上面介绍的这种方式以外我们还可以通过Vue组件中给我们提供的一个component标签来实现



Vue提供了 component 来展示对应名称的组件，component 是一个占位符, :is 属性,可以用来指定要展示的组件的名称

效果



完整代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="./lib/vue-2.4.0.js"></script>
</head>
<body>
    <div id="app">
            <a href="" @click.prevent="comName='login'">登录</a>
            <a href="" @click.prevent="comName='register'">注册</a>

            <component :is="comName"></component>
    </div>
    <script>

        // 创建登录的组件
        Vue.component("login",{
            template: "<h3>这是一个登录LOGIN组件</h3>"
        })
        // 创建注册的组件
        Vue.component("register",{
            template: "<h3>这是一个注册组件</h3>"
        })

        var vm = new Vue({
            el: "#app",
            data: {
                comName: "login"
            },
            methods: {

            }
        })
    </script>
</body>
</html>

35
36
37
38
39
组件切换-动画
前面我们介绍了 动画 的使用，那么刚好我们可以在切换的时候把动画效果给加上。
添加动画样式:

<style>
    .v-enter,
    .v-leave-to{
        opacity: 0;
        transform: translateX(150px) ;
    }

    .v-enter-active,
    .v-leave-active{
        transition: all 1s ease;
    }
</style>

组件包裹 标签



效果



我们发现动画切换的时候两个是一块执行的，这时我们可以在 transition 标签添加一个 mode属性 来设置动画的模式



搞定~

蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、 网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

第一种情况
新增框内既有各类保险金额，也有保险总费用。当输入一类保险金额时，保险总费用自动累加显示，点击保存之后将所有数据插入数据库。然后查询查询显示在结果列表即可。如下图:

第一种情况可以在前端js中写一个计费方法。获取每个不同类的保险金额，值取到之后在点击保存之前将变量中的值赋值给保险总费用，然后点击保存。代码如下(js中计费的方法写在代码一开始中的method{}中，也就是新增，查询，删除，修改下方即可)：

//计费方法
Vehicle_sum:function(){
var sum  = /^[0-9]\d{0,5}$/;
var trafficCompulsoryInsuranceCost=$("#vehicleInsurance_add_trafficCompulsoryInsuranceCost").textbox('getValue');
trafficCompulsoryInsuranceCost=parseInt(trafficCompulsoryInsuranceCost);
if(!trafficCompulsoryInsuranceCost == ''){
if(!sum.test(trafficCompulsoryInsuranceCost)){
Message.error("请输入正确的保险！");
return;
}
}
var commercialInsuranceCost=$("#vehicleInsurance_add_commercialInsuranceCost").textbox('getValue');
commercialInsuranceCost=parseInt(commercialInsuranceCost);
if(!commercialInsuranceCost == ''){
if(!sum.test(commercialInsuranceCost)){
Message.error("请输入正确的保险！");
return;
}
}
var carrierInsuranceCost=$("#vehicleInsurance_add_carrierInsuranceCost").textbox('getValue');
carrierInsuranceCost=parseInt(carrierInsuranceCost);
if(!carrierInsuranceCost == ''){
if(!sum.test(carrierInsuranceCost)){
Message.error("请输入正确的保险！");
return;
}
}
var vehicleAndVesselTaxCost=$("#vehicleInsurance_add_vehicleAndVesselTaxCost").textbox('getValue');
vehicleAndVesselTaxCost=parseInt(vehicleAndVesselTaxCost);
if(!vehicleAndVesselTaxCost == ''){
if(!sum.test(vehicleAndVesselTaxCost)){
Message.error("请输入正确的保险！");
return;
}
}
var total = trafficCompulsoryInsuranceCost+commercialInsuranceCost+carrierInsuranceCost+vehicleAndVesselTaxCost;
$("#vehicleInsurance_add_totalCost").textbox("setValue",total);
},

第二种情况
新增的表单中只有各种类别的保险费用，并没有保险费用合计的字段。意思是在新增时只输入各种类别的保险金额，后台拿到各种类型的保险金额之后，在后台将各类保险金额累加，用set方法给totalcost(保险总费用)赋值，插入数据库中。查询是从数据库查询显示在结果列表即可。如下图


第二种情况可以在后台中写一个计费的累加方法。用BigDecimal的add方法进行累加。首先实例化一个BigDecimal的对象totalCost，赋一个初始值为0，然后用保险的对象insurance的get方法获取各种保险的金额，然后用totalCost.add方法将获取每个不同类的保险金额一次加到totalCost中，然后将totalCost用insurance的set方法set到保险总费用的字段中，然后进行插入操作。代码如下(后台中计费的方法写在Service中的新增方法中)：

/**
* 车辆保险新增
* 陈通
* @param insurance
* @param request
* @return
* @throws IOException
*/
public Result insertVehicleInsurance(VehicleInsurance insurance,HttpServletRequest request) throws IOException{
Result result = Result.getInstance();
insurance.setKeyID(IDGenerator.uuid());
//计费方法开始
BigDecimal totalCost = new BigDecimal("0");
        if(insurance.getTrafficCompulsoryInsuranceCost()!=null){
        totalCost=totalCost.add(insurance.getTrafficCompulsoryInsuranceCost());
        }
        if(insurance.getCommercialInsuranceCost()!=null){
        totalCost=totalCost.add(insurance.getCommercialInsuranceCost());
        }
        if(insurance.getCarrierInsuranceCost()!=null){
        totalCost=totalCost.add(insurance.getCarrierInsuranceCost());
        }
        if(insurance.getVehicleAndVesselTaxCost()!=null){
        totalCost=totalCost.add(insurance.getVehicleAndVesselTaxCost());
        }
        insurance.setTotalCost(totalCost);
        //计费方法结束
//插入车辆保险信息,返回受影响的行数
int count=vehicleInsuranceDao.insertVehicleInsurance(insurance);
//插入附件
sysFileService.saveFile(insurance.getKeyID(), Enums.FILE_CATALOG.INSURANCEFILE.getValue(), request);
if (count>0) {
result.setFlag(true);
result.setMessage("车辆保险新增成功!");
}else{
result.setFlag(false);
result.setMessage("车辆保险新增失败!");
}
return result;
}

以上是两种计费方法(前台和后台)。
--------------------- 
作者：ct_?? 
来源：CSDN 
原文：https://blog.csdn.net/weixin_40418595/article/details/94736305 
版权声明：本文为博主原创文章，转载请附上博文链接！

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

多参数柯里
原生bind
实现promise
防抖节流函数
多参数柯里化

参数fn可以是function(a,b,c){}，也可以是function(a,b,c,d,f){}

// 支持多参数传递
function progressCurrying(fn, args) {

    var _this = this
    var len = fn.length;
    var args = args || [];
    return function() {
        var _args = Array.prototype.slice.call(arguments).concat(args);
        // 如果参数个数小于最初的fn.length，则递归调用，继续收集参数
        if (_args.length < len) {
            return progressCurrying.call(_this, fn, _args);
        }

        // 参数收集完毕，则执行fn
        return fn.apply(this, _args);
    }
}

原生js实现bind

Function.prototype.myBind = function(Othis){
  if(typeof this !== "function"){
    return new TypeError("not a function");
  }
  let _this = this;
  let args = [...arguments].slice(1);
  let func = function(){};
  let fBound = function () {
    return _this.apply(this instanceof func ?this:Othis,[...arguments].concat(args));
  }
  func.prototype = _this.prototype;
  fBound.prototype = new func();
  return fBound;
}

防抖函数

//每wait时间内执行一次，若期间被触发，则重新执行
function debounce(func,wait) {
  var timeout ;
  return function(){
    let args = [...arguments];
    let _this = this;
    if(timeout){
      clearTimeout(timeout);
    }
    timeout = setTimeout(function() {
      func.apply(_this,args);
    }, wait);
  }
}

节流函数

//每wait时间执行一次
function throttle(func,wait){
  var timeStart = 0 ;
  return function(){
    let _this = this;
    let args = [...arguments];
    let now = Date().now();
    if(now - timeStart >wait){
      func.apply(_this,args);
      timeStart = now;
    }
  }
}

实现一个promise

    function _Promise(func){
        this.status = 'pending'
        this.result = '' ;
        func(this.resolve.bind(this),this.reject.bind(this));
    }
    _Promise.prototype.resolve = function(result){
        if(this.status == 'pending'){
            this.status = 'fullfilled';
            this.result = result;
        }
    }
    _Promise.prototype.reject = function(error){
        if(this.status == 'pending'){
            this.status = 'rejected';
            this.result = error;
        }
    }
    _Promise.prototype.then = function(preResolve,preReject){
        let _isPromise ;
        if(this.status == 'fullfilled'){
            _isPromise = preResolve(this.result);
        }else if(this.status == 'rejected' && arguments[1]){
             _isPromise = preReject(this.result);
        }
        return _isPromise instanceof _Promise ? _isPromise:this;
    }

实现一个promise.all()

 function promiseAll(promiseArray){
        //首先参数一定是一个数组
        //然后此函数返回的是一个promise,如果全部成功，则返回结果的数组，只要有一个失败，则返回失败的结果
        return new Promise(function (resolve,reject){
            if(!Array.isArray(promiseArray)){
                return reject(new TypeError("not a function"));
            }
            let resolveNum = 0;
            let arrNum = promiseArray.length;
            let resolveResult = [];
            for(let i=0; i<arrNum ;i++){
                (function (i){
                    Promise.resolve(promiseArray[i]).then(function(result){
                        resolveNum ++;
                        resolveResult.push(result);
                        if(resolveNum == arrNum){
                            return resolve(resolveResult);
                        }
                    },function(error){
                        return reject(error);
                    })
                })(i);
            }
        }) //返回的promise结束
        
    }
蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

减少页面加载时间的方法：
1.压缩html css js等文件
2.减少DNS解析
3.减少DOM元素，对于相关操作可以缓存节点
4.改变页面元素样式时尽量操作className，而不是频繁使用xxx.style.（其实还有很多这种DOM修改操作的细节比如opacity替代visibility ，多个DOM统一操作（虽然V8会有缓存优化） ，先将DOM离线，即display：none；修改后显示 ，不要把DOM放在已给循环中作为循环变量 ，不要使用table ）
5.避免不必要的重定向
6.合并js css及图片，减少请求数量
7.使用CDN
8.合理利用缓存
9…

关于CDN？
https://zhuanlan.zhihu.com/p/39028766

CDN中文名“内容分发网路”，作用是减少传播时延，找最近的节点。CDN本质就一个是缓存，只是这个缓存离你特别近，不管是作为用户还是开发人员都能从中享受一点福利。
CDN的优点
1.访问加速
2.减轻服务器负载
3.抗住攻击
CDN的缺点
1.只能对静态资源加速
2.内容更新时需要分发到其他节点
3.代价高昂
与传统网站访问方式的不同
传统的网站会直接解析域名获得IP地址然后发送请求
使用了CDN的网站则增加了缓存层，解析域名→获取对应CNAME域名→对获取的域名进行解析得到缓存服务器的IP地址，将用户的访问请求引导到最优的缓存节点而不是源站。

总结：通过权威DNS服务器来实现最优节点的选择，通过缓存来减少源站的压力。主要应用于静态网页、大文件的下载等等。
应用与踩坑

缓存设置
max-age在Cache-Control中经常用于缓存的控制，可是max-age设置的缓存会应用于一个请求经过的每一级，如果我们希望CDN不缓存那么久，要怎么办呢？那就是s-maxage，它用于设置代理服务器的缓存时间，会覆盖max-age的设置，这样我们可以把max-age用于本地缓存，把s-maxage用于CDN缓存时间，避免脏数据的产生。

缓存命中率
对于一个缓存而言，还有一点非常重要，就是你的缓存到底有没有用，衡量这个东西的就是缓存命中率。如果只是静态资源，在刷新缓存之后，可能导致命中率下降，因此CDN的资源不适合经常刷新，换句话说，如果一个请求结果会经常进行变更，那么CDN基本就没有什么存在的意义了。

判断是否命中缓存
还要考虑的一件事是：这个资源是否命中了CDN，是否是因为CDN导致的问题。

在各大厂商的CDN返回的数据中都会有一个X-Cache，上面内容是Hit或者Miss，还会加上诸如Memory或者Disk的缩写表示内存还是磁盘，如果出现Upstream或者Miss则表示没有命中。

资源预热
缓存设计中，预热是很重要的环节，在最初刚开始启动CDN的时候，CDN上并没有缓存数据，此刻大量的请求全部打向源站，肯定会把源站打挂，预热就是实现缓存热门数据，这样在业务上线时，CDN上已经有所需的数据了

蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

一、父组件给子组件传值

1、父组件调用子组件的时候，绑定动态属性

/*传值可以是值“title”、是方法“run”、是组件“this”*/
<v-header :title="title" :run="run" :home="this"></v-header>
1
2
2、在子组件里面通过props接受父组件传过来的数据

<script>
    export default{
props:['title','run','home']
}
</script>

二、父组件主动获取子组件的数据和方法

1、调用子组件的时候定义一个ref

<v-header ref="header"></v-header>
1
2、在父组件里面通过以下方式获取属性和方法

this.$refs.header.属性
this.$refs.header.方法

三、子组件主动获取父组件的数据和方法

this.$parent.数据
this.$parent.方法

四、非父子组建传值

1、新建一个js文件 然后引入vue 实例化vue最后暴露这个实例

VueEvent.js

import Vue from 'vue';
var VueEvent = new Vue();
export default VueEvent;

2、在要广播的地方引入刚才定义的实例，并进行广播

home.vue

<script>
import VueEvent from './VueEvent.js';
    export default{
        methods:{
            emitNews(){
                /*广播数据*/
                VueEvent.$emit('to-news',this.数据)
            }
        }
}
</script>

3、在要接收数据的地方接受广播

news.vue

<script>
import VueEvent from './VueEvent.js';
    export default{
        /*在生命周期函数里写，编译的时候就调用*/
        mounted(){
            /*接受广播*/
            VueEvent.$on('to-news',function(data){
                console.log(data);
            })
        }
}
</script>

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

一.为什么Bitmap三级缓存？
没有缓存的弊端 ：费流量, 加载速度慢
加入缓存的优点： 省流量，支持离线浏览
二.原理

从内存获取图片, 如果存在, 则显示; 如果不存在, 则从SD卡中获取图片
从SD卡中获取图片, 如果文件中存在, 显示, 并且添加到内存中; 否则开启网络下载图片
从网络下载图片, 如果下载成功, 则添加到缓存中, 存入SD卡, 显示图片
三.代码
(1)添加读写SD卡的权限和网络权限



// //Lrucache存储工具类
public class LruUtils {
private LruCache<String,Bitmap> lruCache;
private long max=Runtime.getRuntime().maxMemory();
public LruUtils(){
lruCache=new LruCache<String,Bitmap>((int)max/8){

        @Override
        protected int sizeOf(String key, Bitmap value) {
            return value.getByteCount();
        }
    };
}
public Bitmap getBitmap(String key){
    return lruCache.get(key);
}
public void setBitmap(String key,Bitmap bitmap){
    lruCache.put(key,bitmap);
}
1
2
3
4
5
6
7
8
9
10
11
12
}
//SD卡工具类
public class SDUtils {

public static void setBitmap(String name, Bitmap bitmap) {

    if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
        File file = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
        File file1 = new File(file, name);

        try {

            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, new FileOutputStream(file1));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}
public static Bitmap getBitmap(String name){

    if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
        File file=Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
        File file1=new File(file,name);

        return BitmapFactory.decodeFile(file1.getAbsolutePath());

    }
    return null;
}

}
//网络

import android.app.AlertDialog;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutionException;

public class NewUtils {
public static Bitmap getBitmap(String url) throws ExecutionException, InterruptedException {
return new MyTask().execute(url).get();
}
static class MyTask extends AsyncTask<String,Void,Bitmap>{
@Override
protected Bitmap doInBackground(String… strings) {
String imageUrl = strings[0];
HttpURLConnection conn = null;
try {
URL url = new URL(imageUrl);
conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
conn.setRequestMethod(“GET”);
if (conn.getResponseCode() == 200) {
InputStream is = conn.getInputStream();
Bitmap bitmap = BitmapFactory.decodeStream(is);
return bitmap;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (conn != null) {
conn.disconnect();
}
}
return null;
}
}

}
//使用三个工具类完成Bitmap的三级缓存
package com.example.administrator.myapplication;

import android.graphics.Bitmap;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;

import java.util.concurrent.ExecutionException;

public class MainActivity extends AppCompatActivity {
private ImageView imageView;
Button button;
private LruUtils lruUtils= new LruUtils();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button=findViewById(R.id.button);
imageView=findViewById(R.id.imageview);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Bitmap bitmap=lruUtils.getBitmap(“czn”);
if (bitmap!=null){
imageView.setImageBitmap(bitmap);
Toast.makeText(MainActivity.this, “图片存内存”, Toast.LENGTH_SHORT).show();
}else{
bitmap=SDUtils.getBitmap(“czn.jpg”);
if (bitmap!=null){
imageView.setImageBitmap(bitmap);
Toast.makeText(MainActivity.this, “图片存SD卡”, Toast.LENGTH_SHORT).show();
lruUtils.setBitmap(“czn”,bitmap);
}else{
try {
bitmap=NewUtils.getBitmap(“http://pic1.win4000.com/wallpaper/e/50d80458e1373.jpg”);
if (bitmap!=null){
imageView.setImageBitmap(bitmap);
Toast.makeText(MainActivity.this, “图片存网络”, Toast.LENGTH_SHORT).show();
SDUtils.setBitmap(“czn.jpg”,bitmap);
lruUtils.setBitmap(“czn”,bitmap);
}else{
Toast.makeText(MainActivity.this, “没有找到”, Toast.LENGTH_SHORT).show();
}

                    } catch (ExecutionException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }
    });
}

}
Bitmap二次采样


import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.ExecutionException;

public class Main2Activity extends AppCompatActivity {
Button bt;
ImageView imageView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main2);
bt=findViewById(R.id.bt);
imageView=findViewById(R.id.mimage);
bt.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
Bitmap bitmap = new MyTask().execute(“https://cdn.duitang.com/uploads/item/201211/24/20121124230042_Bfhim.jpeg”).get();
imageView.setImageBitmap(bitmap);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}

        }

    });
}
class MyTask extends AsyncTask<String,Object,Bitmap>{

    @Override
    protected Bitmap doInBackground(String... strings) {
        try {
            URL url = new URL(strings[0]);
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            if(urlConnection.getResponseCode()==200){
                InputStream inputStream = urlConnection.getInputStream();
                //将inputStream流存储起来
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                byte[] bytes = new byte[1024];
                int len=0;
                while((len=inputStream.read(bytes))!=-1){
                    byteArrayOutputStream.write(bytes,0,len);
                }
                //桶：网络的图片都放在数组里面了
                byte[] data = byteArrayOutputStream.toByteArray();
                //TODO 1：第一次采样：只采边框 计算压缩比例
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inJustDecodeBounds=true;//设置只采边框
                BitmapFactory.decodeByteArray(data,0,data.length,options);//采样
                int outWidth = options.outWidth;//获得原图的宽
                int outHeight = options.outHeight;//获得原图的高
                //计算缩放比例
                int size=1;
                while(outWidth/size>100||outHeight/size>100){
                    size*=2;
                }
                //TODO 2:第二次采样：按照比例才像素
                options.inJustDecodeBounds=false;//设置只采边框为fasle
                options.inSampleSize=size;//设置缩放比例
                Bitmap bitmap= BitmapFactory.decodeByteArray(data,0,data.length,options);//采样
                return  bitmap;
            }

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}
蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、网站建设 、平面设计服务。

如果您想订阅本博客内容，每天自动发到您的邮箱中， 请点这里

Fragment，在Android中指的是碎片，也就是在不切换Activity时进行页面的切换，这是Android中的一个重点的内容，很多的应用程序中都有这样的功能，所以，接下来让我们具体的学习一下Fragment的使用
首先，要将一个Fragment给创建出来。
新建一个类，让这个类继承Fragment，并重写onCreatView()方法，之后，使用onCreatView中的inflater将一个布局文件转换为视图，并返回这个视图


之后在MainActivity中获得一个Fragment的管理者

之后我们通过这个管理者的beginTransaction()的方法获取事务管理者

然后，我们将之前写好的Fragment类给进行实例化

之后，我们使用事务管理者的replace()方法来给我们需要的控件上将我们的Fragment给显示出来

之后，使用事务管理者提交事务，这样我们的Fragment就完美的显示出来了

碎片可以在不影响Activity时进行一个页面的切换，所以，我们需要把我们需要显示的所有的Fragment都放到FrameLayout布局上
这样就可以实现Fragment的切换了
同时，在进行Fragment可以给Fragment添加一个回退栈的功能，使得每次按返回键是返回的上一个Fragment，而不是直接退出整个程序了


下面我们讲一下Fragment的生命周期
Fragment的生命周期分为11个部分，分别为：
onAttach()
onCreatView()
onCreat()
onActivityCreated()
onStart()
onResume()
onPause()
onStop()
onDestoryView()
onDestory()
onDetach()
Fragment的生命周期和Activity的生命周期一样重要，都是面试时的重点，一定要背下来

其次还要学习关于Fragment的传值
Fragment的传值分为两种方法，分别是Handler传值和接口回调方法，接下来就来学习一下两种不同的传值方式
首先是Handler的传值 ，
第一步是在我们需要拿到值的Fragment中建立一个静态的Handler，之后重写handleMessage()方法

第二步，在传值的Fragment的调用Handler进行传值

这样就可以实现了Fragment的Handler之间的传值

然后我们接着说关于接口回调的传值
首先定义一个外部接口

之后呢，在传值的Fragment里传递数据

然后，我们在接收的Fragment里实现接口并重写方法即可传递数据

这就是接口回调传递数据的方法
好了，关于Fragment的使用简单说到这里
--------------------- 
蓝蓝设计( www.lanlanwork.com )是一家专注而深入的界面设计公司，为期望卓越的国内外企业提供卓越的UI界面设计、BS界面设计 、 cs界面设计 、 ipad界面设计 、 包装设计 、 图标定制 、 用户体验 、交互设计、网站建设 、平面设计服务。