发现对directive指令研究不深，在这里学习下；
用法大致如下
angular.module("app",[]).directive("directiveName",function(){
return{
//通过设置项来定义
};
})
return对象包含：
restrict
（字符串）可选参数，指明指令在DOM里面以什么形式被声明； 取值有：E(元素),A(属性),C(类),M(注释)，其中默认值为A；
- E(元素)：
- A(属性)：
- C(类)：
- M(注释)：<--directive:directiveName expression-->
priority
(数字)，可选参数，指明指令的优先级，若在单个DOM上有多个指令，则优先级高的先 设置指令的优先级算是不常用 比较特殊的的例子是，angularjs内置指令的ng-repeat的优先级为1000，ng-init的优先级为450；
terminal
（布尔型），可选参数，可以被设置为true或false，若设置为true，则优先级低于此指令的其他指令则无效，不会被调用(优先级相同的还是会执行)
template（字符串或者函数）可选参数，可以是：
- 一段HTML文本
angular.module("app",[]).directive("hello",function(){
return{
restrict:'EA',template:"<div><h3>hello world</h3></div>"
};
})
HTML代码为：<hello></hello>
结果渲染后的HTML为：<hello>
<div><h3>hello world</h3></div>
</hello>
- 一个函数，可接受两个参数tElement和tAttrs
其中tElement是指使用此指令的元素，而tAttrs则实例的属性，它是一个由元素上所有的属性组成的集合（对象）形如：
{
title：‘aaaa’,name:'leifeng'
}
下面让我们看看template是一个函数时候的情况
angular.module("app",[]).directive("directitle",function(){
return{
restrict:'EAC',template: function(tElement,tAttrs){
var _html = '';
_html += '<div>'+tAttrs.title+'</div>';
return _html;
}
};
})
HTML代码：<directitle title='biaoti'></directitle> 渲染之后的HTML：<div>biaoti</div>
因为一段HTML文本，阅读跟维护起来都是很麻烦的，所用通常会使用templateUrl这个。
templateUrl（字符串或者函数），可选参数，可以是
- 一个代表HTML文件路径的字符串
- 一个函数，可接受两个参数tElement和tAttrs（大致同上）
- 注意：在本地开发时候，需要运行一个服务器，不然使用templateUrl会报错 Cross Origin Request Script（CORS）错误
- 由于加载html模板是通过异步加载的，若加载大量的模板会拖慢网站的速度，这里有个技巧，就是先缓存模板
- 你可以再你的index页面加载好的，将下列代码作为你页面的一部分包含在里面。
<script type='text/ng-template' id='woshimuban.html'>
<div>我是模板内容</div>
</script>
这里的id属性就是被设置在templateUrl上用的。
- 另一种办法缓存是:
angular.module("template.html",[]).run(["$templateCache",function($templateCache) {
$templateCache.put("template.html","<div>wo shi mu ban</div>");
}]);
replace
（布尔值），默认值为false，设置为true时候，不显示指令标签名。
scope
- 可选参数，（布尔值或者对象）默认值为false，可能取值：
- 默认值false。表示继承父作用域;
- true,表示继承父作用域，并创建自己的作用域（子作用域）;
- {},表示创建一个全新的隔离作用域；
- $scope的继承机制。用ng-controller这个指令举例， ng-controller（内置指令）可以从父作用域中继承并且创建一个新的子作用域。如下：
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<div ng-init="aaa='父亲'">
parentNode：{{aaa}}
<div ng-controller="myController">
chrildNode： {{aaa}}
</div>
</div>
<script>
angular.module('myApp',[])
.controller('myController',function($scope){
$scope.aaa = '儿子'
})
</script>
</body>
</html>
这时页面显示是
- parentNode：父亲
- chrildNode： 儿子
若去掉 $scope.aaa = '儿子' 则显示
- parentNode：父亲
- chrildNode： 父亲
注意： 1. 若一个元素上有多个指令，使用了隔离作用域，则只有其中一个可以生效； 2. 只有指令模板中的根元素才能获得一个新的作用域，这时候，scope就被设置为true了；
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<div ng-init="aaa='父亲'">
parentNode：{{aaa}}
<div class='one' ng-controller="myController">
chrildNode： {{aaa}}
<div class='two' ng-controller='myController2'>
{{aaa}}
</div>
</div>
</div>
<script>
angular.module('myApp',function($scope){
$scope.aaa = '儿子';
})
.controller('myController2',function($scope){
$scope.aaa = '孙女';
})
</script>
</body>
</html>
页面显示为： parentNode：父亲 chrildNode： 儿子 孙女 上面中class为one那个div获得了指令ng-controller=’myController‘所创建的新的作用域； 而class为two那个div获得了指令ng-controller=’myController2‘所创建的新的作用域； 这就是“只有指令模板中的根元素才能获得一个新的作用域”； 接下来我们通过一个简单明了的例子来说明scope取值不同的差别
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<div ng-controller='MainController'>
父亲: {{name}}
<input ng-model="name" />
<div my-directive></div>
</div>
<script>
angular.module('myApp',[])
.controller('MainController',function ($scope) {
$scope.name = 'father';
})
.directive('myDirective',function () {
return {
restrict: 'EA',scope:false,//改变此处的取值,看看有什么不同
template: '<div>儿子:{{ name }}<input ng-model="name"/></div>'
};
});
</script>
</body>
</html>
依次设置scope的值false，true，{}，结果发现
当为false时候，儿子继承父亲的值，改变父亲的值，儿子的值也随之变化，反之亦如此。（继承不隔离）
当为true时候，儿子继承父亲的值，改变父亲的值，儿子的值随之变化，但是改变儿子的值，父亲的值不变。（继承隔离）
当为{}时候，没有继承父亲的值，所以儿子的值为空，改变任何一方的值均不能影响另一方的值。（不继承隔离）
tip：当你想要创建一个可重用的组件时隔离作用域是一个很好的选择，通过隔离作用域我们确保指令是‘独立’的,并可以轻松地插入到任何HTML app中，并且这种做法防止了父作用域被污染； 2. 隔离作用域可以通过绑定策略来访问父作用域的属性。
- 下面看一个例子
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<div ng-controller='MainController'>
<input type="text" ng-model="color" placeholder="Enter a color"/>
<hello-world></hello-world>
</div>
<script>
var app = angular.module('myApp',[]);
app.controller('MainController',function(){});
app.directive('helloWorld',function(){
return {
scope: false,restrict: 'AE',replace: true,template: '<p style="background-color:{{color}}">Hello World</p>'
}
});
</script>
</body>
</html>
- 运行代码，并在input中输入颜色值
- 但是，但我们将scope设置为{}时候，再次运行上面的代码可以发现页面并不能成功完整显示！
- 原因在于，这里我们将scope设置为{}，产生了隔离作用域。
- 所以在template模板中{{color}}变成了依赖于自己的作用域，而不是依赖于父作用域。
- 因此我们需要一些办法来让隔离作用域能读取父作用域的属性，就是绑定策略。
- 下面我们就来探索设置这种绑定的几种方法
方法：使用@（@attr）来进行单向文本（字符串）绑定
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<div ng-controller='MainController'>
<input type="text" ng-model="color" placeholder="Enter a color"/>
<hello-world color-attr='{{color}}'></hello-world> //注意这里设置了color-attr属性，绑定了{{color}}
</div>
<script>
var app = angular.module('myApp',function(){
return {
scope: {color:'@colorAttr'},//指明了隔离作用域中的属性color应该绑定到属性colorAttr
restrict: 'AE',template: '<p style="background-color:{{color}}">Hello World</p>'
}
});
</script>
</body>
</html>
这种办法只能单向，通过在运行的指令的那个html标签上设置color-attr属性，并且采用{{}}绑定某个模型值。 注意，你也可以再这里直接绑定字符串的颜色值,如：color-attr=“red”； 然后你可以看到表达式{{color}}被赋值给了color-attr。 当表达式的值发生变化时，属性color-attr也会发生变化，所以也改变了隔离作用域中的属性color。 其他方法不再描述，有兴趣的查看原帖。
transclude
（布尔值或者字符‘element’），默认值为false；
- 这个配置选项可以让我们提取包含在指令那个元素里面的内容，再将它放置在指令模板的特定位置。
- 当你开启transclude后，你就可以使用ng-transclude来指明应该在什么地方放置transcluded内容
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<div ng-controller='MainController'>
<div class='a'>
<p>china</p>
<hello-world>
{{name}}
</hello-world>
</div>
</div>
<script>
var app = angular.module('myApp',function($scope){
$scope.name = 'leifeng';
});
app.directive('helloWorld',function(){
return {
scope:{},transclude: true,template: '<div class="b"><div ng-transclude>你看不见我</div></div>'
}
});
</script>
</body>
</html>
运行上面的代码，输出 china leifeng
- 另外当开启transclude，会创建一个新的transclude空间，并且继承了父作用域（即使Scope设置为隔离作用域），
- 上面代码中的{{name}}是依赖于父作用域的，仍然能被渲染出来，就说明了这点。
- 我们再看看生成的html为下图所示，可以发现文本“你看不见我”消失了，这是因为被transclude内容替换掉了。 这里的transclude内容就是{{name}}.
- 接下来再来看看transclude的另一个取值transclude：“element”,那transclude：“element”与transclude：true有什么区别呢？区别在于嵌入的内容，以上面的例子来说，
- 当transclude：true时候，嵌入的内容为{{name}}，
- 而当transclude：“element”时候，嵌入的内容为
angular.module('myApp',controller: function($scope,$transclude) { // 控制器逻辑放在这里 } });
另外还有一些特殊的服务（参数）可以注入 （1）$scope，与指令元素相关联的作用域 （2）$element，当前指令对应的 元素 （3）$attrs，由当前元素的属性组成的对象 （4）$transclude，嵌入链接函数，实际被执行用来克隆元素和操作DOM的函数 - 注意： 除非是用来定义一些可复用的行为，一般不推荐在这使用。 指令的控制器和link函数（后面会讲）可以进行互换。区别在于，控制器主要是用来提供可在指令间复用的行为但link链接函数只能在当前内部指令中定义行为，且无法再指令间复用。 HTML代码: ```js <my-site site="http://www.cnblogs.com/cunjieliu">雷锋叔叔的博客</my-site>
js代码：
<script>
angular.module('myApp',[]).directive('mySite',function () {
return {
restrict: 'EA',//注意此处必须设置为true
controller:
function ($scope,$transclude,$log) { //在这里你可以注入你想注入的服务
$transclude(function (clone) {
var a = angular.element('<a>');
a.attr('href',$attrs.site);
a.text(clone.text());
$element.append(a);
});
$log.info("hello everyone");
}
};
});
</script>
require(字符串或者数组)
- 字符串代表另一个指令的名字，它将会作为link函数的第四个参数
- 具体用法可以举个例子说明 假设现在我们要编写两个指令，两个指令中的link链接函数中存在有很多重合的方法， 这时候我们就可以将这些重复的方法写在第三个指令的controller中（controller经常用来提供指令间的复用行为）
然后在这两个指令中，require这个拥有controller字段的的指令（第三个指令）， 最后通过link链接函数的第四个参数就可以引用这些重合的方法了。
<!doctype html>
<html ng-app="myApp">
<head>
<script src="http://cdn.staticfile.org/angular.js/1.2.10/angular.min.js"></script>
</head>
<body>
<outer-directive>
<inner-directive></inner-directive>
<inner-directive2></inner-directive2>
</outer-directive>
<script>
var app = angular.module('myApp',[]);
app.directive('outerDirective',function() {
return {
scope: {},controller: function($scope) {
this.say = function(someDirective) {
console.log('Got:' + someDirective.message);
};
}
};
});
app.directive('innerDirective',require: '^outerDirective',link: function(scope,elem,attrs,controllerInstance) {
scope.message = "Hi,leifeng";
controllerInstance.say(scope);
}
};
});
app.directive('innerDirective2',shushu";
controllerInstance.say(scope);
}
};
});
</script>
</body>
</html>
上面例子中的指令innerDirective和指令innerDirective2复用了定义在指令outerDirective的controller中的方法
也进一步说明了，指令中的controller是用来让不同指令间通信用的。
另外我们可以在require的参数值加上下面的某个前缀，这会改变查找控制器的行为：
（1）没有前缀，指令会在自身提供的控制器中进行查找，如果找不到任何控制器，则会抛出一个error
（2）？如果在当前的指令没有找到所需的控制器，则会将null传给link连接函数的第四个参数
（3）^如果在当前的指令没有找到所需的控制器，则会查找父元素的控制器
（4）?^组合