angular学习笔记(二十九)-$q服务
angular中的$q是用来处理异步的(主要当然是http交互啦~).
$q采用的是promise式的异步编程.什么是promise异步编程呢?
异步编程最重要的核心就是回调,因为有回调函数,所以才构成了异步编程,而回调有三个关键部分:
一是什么时候执行回调,二是执行什么回调,三是回调执行的时候传入什么参数.
就以最常见的jquery Ajax举例,发送一个请求后:
什么时候执行回调: 请求成功(或者失败)的时候
执行什么回调: 根据请求成功或者失败,执行相应的回调函数
回调执行的时候传入的什么参数: 也就是后台返回的数据
在过去大多数场景下,我们的异步编程都是这样的格式:
function a(callback1,callback2){
var bool;
var data;
/*a函数要做的事情,做完后会判断bool是true还是false,并且给data赋值*/;
//a函数完事儿,根据a函数的执行结果执行相应的回调函数
if(bool){
callback1(data)
}
if(!bool){
callback2(data)
}
}
a(function(data){
/*回调函数1的处理*/
},function(data){
/*回调函数2的处理*/
}
)
运行:http://jsfiddle.net/s2ebjon0/
这个例子只有一次回调,但如果回调中还要嵌套回调:
function a(callback1,callback2){
var bool;
var data;
/*a函数要做的事情,做完后会判断bool是true还是false,并且给data赋值;*/
bool=true;
data='code_bunny'
//a函数完事儿,根据a函数的执行结果执行相应的回调函数
if(bool){
callback1(data,function(data){
console.log('success:'+data)
},function(data){
console.log('fial:'+data)
})
}
if(!bool){
callback2(data)
}
}
a(function(data,callback1,callback2){
alert('成功'+data);
var dataNew;
var bool;
dataNew = data;
bool = false;
if(bool){
callback1(data)
}
if(!bool){
callback2(data)
}
},function(data){
/*回调函数2的处理*/
alert('失败'+data)
}
)
运行: http://jsfiddle.net/kbyy73dn/1/
我就不接着写如果回调中嵌套回调再嵌套回调再...
总之一句话,使用传统的回调函数作为参数来编写方式来实现异步,是十分麻烦的,代码可读性十分的差.而promise式的编程则把这个过程抽象化,只关注上面说到的三个关键点(什么时候执行回调,执行什么回调,回调执行的时候传入什么参数),在这篇文章不关心它究竟是如何做到的,只关心它是怎么使用的:
promise式异步有两个重要的对象,一个defer对象,一个promise对象,每个defer对象都有和它绑定的promise对象,他们之间的关系是一一对应的.defer对象负责告知promise对象什么时候执行回调,执行什么回调,回调执行的时候传入什么参数,而promise对象负责接收来自defer对象的通知,并且执行相应的回调.
举个最简单的例子:
var HttpREST = angular.module('Async',[]);
HttpREST.controller('promise',function($q,$http){
//创建了一个defer对象;
var defer = $q.defer();
//创建了defer对象对应的promise
var promise = defer.promise;
//promise对象定义了成功回调函数,失败回调函数
promise.then(function(data){console.log('成功'+data)},function(data){console.log('失败'+data)});
//对promise发起通知: 1.执行这段代码的时候就是执行回调的时候, 2.调用resolve方法,表示需要被执行的是成功的回调, 3.resolve里的参数就是回调执行的时候需要被传入的参数
defer.resolve('code_bunny') });
下面来看下$q的完整api
$q的方法:
一. $q.defer():
返回一个对象.一般把它赋值给defer变量:
var defer = $q.defer()
※defer的方法:
(一)defer.resolve(data)
对promise发起通知,通知执行成功的回调,回调执行的参数为data
(二)defer.reject(data)
对promise发起通知,通知执行失败的回调,回调执行的参数为data
(三)defer.notify(data)
对promise发起通知,通知执行进度的回调,回调执行的参数为data
※defer的属性:
(一)defer.promise
※defer.promise的属性:
1.defer.promise.$$v
promise的$$v对象就是对应的defer发送的data,当defer还没有发送通知时,$$v为空.
有一点很重要,假设,我们令$scope.a = defer.promise,那么页面在渲染{{a}}时,使用的是a.$$v来渲染a这个变量的.并且修改a变量,视图不会发生变化,需要修改a.$$v,视图才会被更新,具体请参考:
http://www.cnblogs.com/liulangmao/p/3907307.html
※defer.promise的方法:
1.defer.promise.then([success],[error],[notify]):
.then方法接受三个参数,均为函数,函数在接受到defer发送通知时被执行,函数中的参数均为defer发送通知时传入的data.
[success]: 成功回调,defer.resolve()时调用
[error]: 失败回调,defer.reject()时调用
[notify]: 进度回调,defer.notify()时调用
.then()方法返回一个promise对象,可以接续调用.then(),注意,无论.then()是调用的success函数,还是error函数,还是notify函数,发送给下一个promise对象的通知一定是成功通知,而参数则是函数的返回值.也就是说,then()方法里的函数被执行结束后,即为下一个promise发送了成功通知,并且把返回值作为参数传递给回调.
eg1: (单次调用)
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
</div>
</body>
</html>
js:
var HttpREST = angular.module('Async',[]);
//defer.resolve(),defer.reject(),defer.notify()
HttpREST.controller('promise',function($q,$http,$scope){
var defer = $q.defer(); //创建了一个defer对象;
var promise = defer.promise; //创建了defer对象对应的promise
promise.then(function(data){$scope.name='成功'+data},function(data){$scope.name='失败'+data},function(data){$scope.name='进度'+data});
$http({
method:'GET',
url:'/name'
}).then(function(res){
defer.resolve(res.data)
},function(res){
defer.reject(res.data)
})
});
如果正确创建后台对于'/name'的请求处理,在一秒后返回'code_bunny',则一秒后页面显示:
如果后台没有创建对于'/name'的请求处理,则页面直接显示:
eg2: (链式调用)
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
<h3>{{name2}}</h3>
</div>
</body>
</html>
js:
var HttpREST = angular.module('Async',[]);
//.then()的链式调用
HttpREST.controller('promise',function($q,$http,$scope){
var defer = $q.defer(); //创建了一个defer对象;
var promise = defer.promise; //创建了defer对象对应的promise
promise.then(function(data){
$scope.name='成功'+data;
return data+'2'
},function(data){
$scope.name='失败'+data;
return data+'2'
},function(data){
$scope.name='进度'+data;
return data+'2'
}).then(function(data){
$scope.name2 = '成功'+data
},function(data){
$scope.name2 = '失败'+data
});
$http({
method:'GET',
url:'/name'
}).then(function(res){
defer.resolve(res.data)
},function(res){
defer.reject(res.data)
})
});
如果正确创建后台对于'/name'的请求处理,在一秒后返回'code_bunny',则一秒后页面显示:
,可以看到,第一个.then()的成功的回调返回的data+'2'这个值,被传到了下一个.then()的成功回调的data参数中
如果后台没有创建对于'/name'的请求处理,则页面直接显示:
,可以看到,就算第一个.then()调用的是失败回调,但是它发给下一个promise的通知依然是成功通知,data值就是失败回调的返回值
2.defer.promise.catch([callback])
相当于.then(null,[callback])的简写. 直接传入失败回调.返回一个promise对象.发给下一个promise对象的通知依然是成功通知.data值就是回调的返回值.
*很早的angualr版本是没有这个方法的.
eg:
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
<h3>{{name2}}</h3>
</div>
</body>
</html>
js:
//.catch()
HttpREST.controller('promise', function ($q, $http, $scope) {
var defer = $q.defer(); //创建了一个defer对象; var promise = defer.promise; //创建了defer对象对应的promise promise.catch(function (data) {
$scope.name = data;
return data+2
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
}); $http({
method: 'GET',
url: '/name'
}).then(function (res) {
defer.resolve(res.data)
}, function (res) {
defer.reject(res.data)
})
});
后台不创建'/name'的get请求响应, 得到的结果如下: 
可以看到,promise对象收到通知,执行失败回调,然后返回新的promise,对新的promise来说,收到的通知还是执行成功回调.回调的参数是catch里的函数的返回值.如果写成:
promise.then(null,function (data) {
$scope.name = data;
return data+2
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
});
两者是完全一致的.
注意,如果后台正确创建了'/name'的get请求响应, 那么,得到的结果会是:
也就是说,catch()方法如果收到的通知不是执行失败回调,而是执行成功回调,它直接返回一个promise对象进行链式调用,等于把成功通知传给了下一个promise.
由于catch([callback])方法得到的和.then(null,[callback])方法是完全一致的,代码上也米有精简多少,所以一般就直接用.then就好了.
3.defer.promise.finally([callback])
.finally只接受一个回调函数,而且这个回调函数不接受参数.无论defer发送的通知是成功,失败,进度,这个函数都会被调用.
.finally也返回一个promise对象,和上面两个方法不同的是,它为下一个promise对象发送的通知不一定是成功通知,而是传给finally的通知类型.也就是说,如果defer给promise发送的是失败通知,那么,finally()得到的promise它收到的也会是失败通知,得到的参数也不是finally的返回值,而是第一个defer发出的通知所带的data.
*很早的angualr版本是没有这个方法的.
eg:
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
<h3>{{name2}}</h3>
</div>
</body>
</html>
js:
//.finally()
HttpREST.controller('promise', function ($q, $http, $scope) {
var defer = $q.defer(); //创建了一个defer对象; var promise = defer.promise; //创建了defer对象对应的promise promise.finally(function () {
$scope.name = '已接收通知';
return 'code_dog';
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
}); $http({
method: 'GET',
url: '/name'
}).then(function (res) {
defer.resolve(res.data)
}, function (res) {
defer.reject(res.data)
})
});
后台不创建'/name'的get请求响应, 得到的结果如下: 
后台正确创建'/name'的get请求响应, 得到结果如下:
可以看到,当promise收到通知的时候执行了fianlly里的回调,然后返回的promise收到的通知和第一个promise收到的通知是一致的,不会受到finally中的回调的任何影响.
-------------------------------------------------------------------------------------------------------------------------------------------------------
二. $q.reject(data):
这个方法(在我的认知范围里),就只能在promise的.then(funciton(){})函数里面调用.作用是给.then()返回的下一个promise发送错误信息,并且给错误回调传入参数data
eg1:(.then方法里使用)
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
<h3>{{name2}}</h3>
</div>
</body>
</html>
js:
HttpREST.controller('promise', function ($q, $http, $scope) {
var defer = $q.defer(); //创建了一个defer对象;
var promise = defer.promise; //创建了defer对象对应的promise
promise.then(function (data) {
return $q.reject(data+'2')
},function(){
return $q.reject(data+'2')
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
});
$http({
method: 'GET',
url: '/name'
}).then(function (res) {
defer.resolve(res.data)
}, function (res) {
defer.reject(res.data)
})
});
后台正确创建'/name'的get请求响应时,得到的结果是:
后台没有正确创建'/name'的get请求响应时,得到结果:
可以看到,在then()方法的函数中,用$q.reject(data)来包装返回值,可以给下一个返回的promise发送失败通知并发送data参数.所以无论promise收到的是成功通知还是失败通知,下一个promise收到的都是失败通知.
eg2:(.finally方法里调用)
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
<h3>{{name2}}</h3>
</div>
</body>
</html>
js:
HttpREST.controller('promise', function ($q, $http, $scope) {
var defer = $q.defer(); //创建了一个defer对象;
var promise = defer.promise; //创建了defer对象对应的promise
promise.finally(function () {
return $q.reject('code_dog')
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
});
$http({
method: 'GET',
url: '/name'
}).then(function (res) {
defer.resolve(res.data)
}, function (res) {
defer.reject(res.data)
})
});
无论后台是否正确创建'/name'的get请求响应,得到结果都是:
.因为.finally()的回调是不能接受到data参数的.所以返回值都是一样.
上面已经说过,使用.finally方法的时候,回调是不能接受参数的,回把对promise发的通知原封不动的(成功失败,data)发送给下一个promise对象.
但是,如果我在.finally的回调里用$q.reject(data)来包装了返回值,那么发送给下一个promise的通知会以$q.reject(data)为准,也就是'失败通知',回调参数为data.
三. $q.all([promise1,promise2,...]):
$q.all接受一个数组类型的参数,数组的值为多个promise对象.它返回一个新的promise对象.
当数组中的每个单一promise对象都收到了成功通知,这个新的promise对象也收到成功通知(回调参数是一个数组,数组中的各个值就是每个promise收到的data,注意顺序不是按照单个promise被通知的顺序,而是按照[promise1,promise2]这个数组里的顺序)
当数组中的某个promise对象收到了失败通知,这个新的promise对象也收到失败通知,回调参数就是单个promise收到的失败通知的回调参数
eg:
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
<style type="text/css">
h4 {
color:red
}
</style>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name1}}</h3>
<h3>{{name2}}</h3>
<h3>{{age1}}</h3>
<h3>{{age2}}</h3>
<h4>{{three}}</h4>
</div>
</body>
</html>
js:
//$q.all()
HttpREST.controller('promise', function ($q, $http, $scope) {
var defer1 = $q.defer(); //创建了一个defer1对象; var promise1 = defer1.promise; //创建了defer1对象对应的promise1 var defer2 = $q.defer(); //再创建了一个defer2对象; var promise2 = defer2.promise; //创建了新的defer2对象对应的promise2 //promise1收到通知后执行的回调:给name1和name2赋值
promise1.then(function (data) {
$scope.name1 = data;
return data+'.2'
},function(data){
$scope.name1 = data;
return data+'.2'
}).then(function (data) {
$scope.name2 = 'promise1成功' + data
}, function (data) {
$scope.name2 = 'promise1失败' + data
});
//promise2收到通知后执行的回调:给age1和age2赋值
promise2.then(function (data) {
$scope.age1 = data;
return data+'.2'
},function(data){
$scope.age1 = data;
return data+'.2'
}).then(function (data) {
$scope.age2 = 'promise2成功' + data
}, function (data) {
$scope.age2 = 'promise2失败' + data
});
//创建一个promise3,它依赖于promise1和promise2
var promise3 = $q.all([promise1,promise2]);
promise3.then(function(data){
$scope.three = data;
},function(data){
$scope.three = data;
}); $http({
method: 'GET',
url: '/name'
}).then(function (res) {
defer1.resolve(res.data)
}, function (res) {
defer1.reject(res.data)
}); $http({
method: 'GET',
url: '/age'
}).then(function (res) {
defer2.resolve(res.data)
}, function (res) {
defer2.reject(res.data)
})
});
(1)后台node正确创建两个get请求的响应:
app.get('/name',function(req,res){
setTimeout(function(){res.send('code_bunny')},2000)
});
app.get('/age',function(req,res){
setTimeout(function(){res.send('18')},1000)
});
一秒后显示:
两秒后显示:
可以看到,当promise1和promise2都收到成功通知后,promise3也收到成功通知,而它的回调的参数data就是一个数组,数组里的两个值分别是promise1收到的data和promise2收到的data,注意顺序,这里先收到通知的是promise2,但是promise3的data数组里值的顺序和promise收到通知的顺序无关.只和$q.all([])这个数组里的顺序一致.
(2)后台node只创建了'/name'一个get请求的响应:
显示结果:
可以看到,由于'/age'请求错误,promise2被通知失败,所以promise3也立刻被通知失败,收到的data参数也和promise2收到的data一致
四. $q.when(obj,[success],[error],[notify]):
.when接受四个参数,其中,第二,第三,第四个参数都是函数,相当于promise.then()里面的三个参数. 第一个参数有两种可能:
1. 第一个参数不是promise对象: 直接调用成功回调,回调的参数就是第一个参数本身
eg:
html:
//$q.when()
HttpREST.controller('promise', function ($q, $http, $scope) { $q.when('code_dog',function(data){
$scope.name = data;
return data+'2'
},function(data){
$scope.name = data;
return data+'2'
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
}); });
显示结果:
.when()的第一个参数不是promise对象,而是字符串'code_dog',所以它直接执行成功回调,也会返回下一个promise进行链式调用, 和一般的.then()是没有区别的.
在这种情况下其实不需要传入第三,第四个参数,因为第一个参数如果不是promise,那么它只会执行成功回调.
2. 第一个参数是一个promise对象:
当这个promise对象收到通知的时候,调用回调.回调就是第二,三,四个参数...(相当于.then([success],[error],[notify]))
另外,.when()返回的对象也就相当于.then()返回的对象.都是一个新的promise对象,都可以接收到回调发送的通知和参数...
可以理解为,
var defer = $q.defer();
defer.promise.then([success],[error],[notify])
这一段也可以写成:
var defer = $q.defer();
$q.when(defer.promise,[success],[error],[notify])
eg:
html:
<!DOCTYPE html>
<html ng-app = 'Async'>
<head>
<title>19. $q异步编程</title>
<meta charset="utf-8">
<script src="angular.js"></script>
<script src="script.js"></script>
</head>
<body>
<div ng-controller = "promise">
<h3>{{name}}</h3>
<h3>{{name2}}</h3>
</div>
</body>
</html>
js:
//$q.when()
HttpREST.controller('promise', function ($q, $http, $scope) {
var defer = $q.defer(); //创建了一个defer对象; var promise = defer.promise; //创建了defer对象对应的promise $q.when(promise,function(data){
$scope.name = data;
return data+'2'
},function(data){
$scope.name = data;
return data+'2'
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
}); /* 这样写得到的结果也是等价的.
promise.then(function(data){
$scope.name = data;
return data+'2'
},function(data){
$scope.name = data;
return data+'2'
}).then(function (data) {
$scope.name2 = '成功' + data
}, function (data) {
$scope.name2 = '失败' + data
});
*/ $http({
method: 'GET',
url: '/name'
}).then(function (res) {
defer.resolve(res.data)
}, function (res) {
defer.reject(res.data)
}); });
和注释掉的那一段写法完全等价.
所以,在这种情况下.when()只是对.then()的一个包装.
最后,api里面说到:defer对象发送消息不会立即执行的，而是把要执行的代码放到了rootScope的evalAsync队列当中，当时scope.$apply的时候才会被promise接收到这个消息。
虽然不太明白这段话的意思,个人理解是大多数时候,scope是会自动$apply的...如果在什么时候遇到promise没有收到通知,那么就试试看scope.$apply执行一下.
完整代码:https://github.com/OOP-Code-Bunny/angular/tree/master/OREILLY/19%20%24q%E5%92%8Cpromise
angular学习笔记(二十九)-$q服务的更多相关文章
- angular学习笔记(二十八-附1)-$resource中的资源的方法
通过$resource获取到的资源,或者是通过$resource实例化的资源,资源本身就拥有了一些方法,$save,$delete,$remove,可以直接调用来保存该资源: 比如有一个$resour ...
- angular学习笔记(二十八-附2)-$http,$resource中的promise对象
下面这种promise的用法,我从第一篇$http笔记到$resource笔记中,一直都有用到: HttpREST.factory('cardResource',function($resource) ...
- angular学习笔记(二十八)-$http(6)-使用ngResource模块构建RESTful架构
ngResource模块是angular专门为RESTful架构而设计的一个模块,它提供了'$resource'模块,$resource模块是基于$http的一个封装.下面来看看它的详细用法 1.引入 ...
- angular学习笔记(二十六)-$http(4)-设置请求超时
本篇主要讲解$http(config)的config中的timeout项: $http({ timeout: number }) 数值,从发出请求开始计算,等待的毫秒数,超过这个数还没有响应,则返回错 ...
- angular学习笔记(二十五)-$http(3)-转换请求和响应格式
本篇主要讲解$http(config)的config中的tranformRequest项和transformResponse项 1. transformRequest: $http({ transfo ...
- angular学习笔记(二十四)-$http(2)-设置http请求头
1. angular默认的请求头: 其中,Accept 和 X-Requested-With是$http自带的默认配置 Accept:application/json,text/plain ...
- angular学习笔记(二十二)-$http.post
基本语法: $http.post('url',{},{}).success(function(data,status,headers,config){ }).error(function(data,s ...
- angular学习笔记(二十)-表单验证
本篇主要介绍angular中的表单验证: 表单验证主要有以下一些内容: 1. required指令: 相当于html5的required属性,验证不能为空 2. ng-maxlength属性: 验证内 ...
- angular学习笔记(三十)-指令(2)-restrice,replace,template
本篇主要讲解指令中的 restrict属性, replace属性, template属性 这三个属性 一. restrict: 字符串.定义指令在视图中的使用方式,一共有四种使用方式: 1. 元素: ...
随机推荐
- 从零开始学Python第六周：面向对象基础（需修改）
标签(空格分隔): 面向对象 一,面向对象基础 (1)面向对象概述 面向过程:根据业务逻辑从上到下写代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类 ...
- 21、ASP.NET MVC入门到精通——ASP.NET MVC4优化
本系列目录:ASP.NET MVC4入门到精通系列目录汇总 删除无用的视图引擎 默认情况下,ASP.NET MVCE同时支持WebForm和Razor引擎,而我们通常在同一个项目中只用到了一种视图引擎 ...
- Java基础学习总结 -- 图形用户界面GUI
虽然目前Java算不上前端开发的主力,但是作为Java入门基础的一部分,学习Java的GUI编程还是有必要的,而且可以做出一些小且有趣的图形程序来提高学习热情.本篇学习总结均为一个Beginner的笔 ...
- 【blade04】用面向对象的方法写javascript坦克大战
前言 javascript与程序的语言比如C#或者java不一样,他并没有“类”的概念,虽然最新的ECMAScript提出了Class的概念,我们却没有怎么用 就单以C#与Java来说,要到真正理解面 ...
- CSS3 Transitions, Transforms和Animation的使用
一.前言 CSS3动画相关的几个属性是:transition, transform, animation:分别理解为过渡,变换,动画.虽意义相近,但具体的功能和在CSS3中承担的工作有一定的差异. t ...
- 简单的学习心得：网易云课堂Android开发第三章自定义控件
这一章分三部分: (1)自定义控件:老师先简单讲解了一些细节,如为什么不用px,而要用dp,只因机型的屏幕分辨率不同,用px会导致差异太大.然后演示了制作自定义控件的步骤,先在xml文件中添加对应的自 ...
- 初识android中的动画
动画效果可以大大提高界面的交互效果,因此,动画在移动开发中的应用场景较为普遍.掌握基本的动画效果在成熟的软件开发中不可或缺.除此之外,用户对于动画的接受程度远高于文字和图片,利用动画效果可以加深用户对 ...
- Touch ID使用
前言:如果图片看不了请移步:简书 Touch ID简介 Touch ID指纹识别作为iPhone 5s上的"杀手级"功能早已为人们所熟知,目前搭载的设备有iphone SE.iPh ...
- MRC下多个对象的内存管理
//set方法传递进来对象的生命周期,要求是在当前对象销毁之前,它一直存在就好- (void)setCar:(Car *)car{ //1.判断set方法传递进来的值是否与成员变量中保存的是同一个对象 ...
- Android中Listview点击item不变颜色以及设置listselector 无效
Android中Listview点击item不变颜色以及设置listselector 无效 这是同一个问题,Listview中点击item是会变颜色的,因为listview设置了默认的listsele ...