内聚和耦合（自己的理解）

网上对于内聚和耦合的资料太多，这里结合我的感受和其他人的答案http://blog.csdn.net/zhiquan/article/details/4255161谈谈自己的理解

以下是我对内聚和耦合的理解（例子来源于生活）。

　　1.内聚：

　　　　i.偶然内聚：如果一个模块的各成分之间毫无关系，则称为偶然内聚。

　　　　　　eg.在敲代码时，我们通常对一段代码进行初始化function init(){}。而对各个模块进行的初始化代码通常都是没有关系的，我们将这些代码包装成一个模块，此时这个模块就是偶然内聚的（杨老师在课上提出过这种内聚方式）。

　　　　ii.逻辑内聚。几个逻辑上相关的功能被放在同一模块中，则称为逻辑内聚。如一个模块读取各种不同类型外设的输入。尽管逻辑内聚比偶然内聚合理一些，但逻辑内聚的模块各成分在功能上并无关系，即使局部功能的修改有时也会影响全局，因此这类模块的修　           　 改也比较困难。

　　　　　　eg.通过模块读取参数不同来执行不同的方法，我感觉类似于函数的重载。在我的快乐运算中有通过传入的参数判断执行的具体方法。此时属于逻辑内聚。代码自：https://github.com/yanyige/CourseWork/blob/master/Week6/js/generation.js）：

　　　　　　　　其中，通过传入的参数来确定生成算式的不同。

　　　　iii.时间内聚。如果一个模块完成的功能必须在同一时间内执行（如系统初始化），但这些功能只是因为时间因素关联在一起，则称为时间内聚。

　　　　　　eg.这里例子同偶然内聚，将没有关系（只是时间因素的关系）的代码包装到一起，构成一个代码块。

　　　　（4） 过程内聚。如果一个模块内部的处理成分是相关的，而且这些处理必须以特定的次序执行，则称为过程内聚。

　　　　　　eg.在快乐运算中，显示每条答案时候必须先计算所有题目（每次生成5道题）的答案，再依次显示到相应位置中。此时，先生成，再计算，最后显示，形成了过程内聚。代码自：https://github.com/yanyige/CourseWork/blob/master/Week6/js/generation.js）：

　　　　　　

function showFormula(items) { //显示公式并且计算答案



    for(var j = 0 ; j < items.length ; j++){

        var str = items[j];
        var strFormula = transforFraction(str);
        var text = document.getElementById("problem-table").children[0].children;
        text[j].children[1].innerHTML = strFormula;
        // console.log('strFormula = '+ strFormula);
        var S1 = [] // 保存运算符的栈
        var S2 = [] // 保存中间结果的栈

        for (var i = 0; i < str.length; i++) {
            // if (!isNaN(str[i])){
            if(str[i] instanceof Fraction){
                S2.push(str[i]);
            }else if(isOperate(str[i])){
                if(!S1.length){
                    S1.push(str[i]);
                } else{
                    var s1Top = S1.pop();
                    S1.push(s1Top);
                    if(s1Top == '('){
                        S1.push(str[i]);
                    }
                    else{
                        var prior1 = getPriorty(s1Top);
                        var prior2 = getPriorty(str[i]);
                        if(prior1 < prior2){
                            S1.push(str[i]);
                        }else{
                            var tempOp = S1.pop();
                            S2.push(tempOp);
                            i --;
                        }
                    }
                }
            }else if(str[i] == '('){
                S1.push(str[i]);
            }else if(str[i] == ')'){
                var tempOp = S1.pop();
                while(tempOp != '('){
                    S2.push(tempOp);
                    tempOp = S1.pop();
                }
            }

        }

        while(S1.length){
            var tempOp = S1.pop();
            S2.push(tempOp);
        }



        ANS = getAns(S2);        

        // anss.push(Number(ANS.toFixed(2)));
        // allAnss.push(Number(ANS.toFixed(2)));
        anss.push(ANS);
        allAnss.push(ANS);

    }
}

　　　　（5） 通信内聚。如果一个模块的所有成分都操作同一数据集或生成同一数据集，则称为通信内聚。

　　　　　　eg.在快乐运算中，一次“小试牛刀”中的题目保存var allFormulas = [];这个数组中，每次计算或者添加算式均在操作此数组，这时形成了通信内聚。代码自：https://github.com/yanyige/CourseWork/blob/master/Week6/js/generation.js）：

　　　　

var anss=[];
var ANS;//记录结果
var youranss = [];
var score = 0;
var tScore = 0;
var allFormulas = []; //通信内聚
var allAnss=[];//通信内聚
var allYourAnss=[];//通信内聚

　　　　（6） 顺序内聚。如果一个模块的各个成分和同一个功能密切相关，而且一个成分的输出作为另一个成分的输入，则称为顺序内聚。

　　　　　　eg.在快乐运算中，计算方法(function showFormula(items){})接受生成方法(function getFormula(MAXNUM, MAXDIGIT, PUNCTUATION, BRACKET, DENOMINATOR){})的返回值item。此时形成了顺序内聚。

　　　　
　　　　（7） 功能内聚。模块的所有成分对于完成单一的功能都是必须的，则称为功能内聚。

　　　　　　eg.在之前未完成作品计算器中，计算器中“取反”操作，“点击数字”操作，“点击运算符操作”，都是为了完成计算表达式。此时属于功能内聚。

 

　　2.耦合

　　　　（1）内容耦合。当一个模块直接修改或操作另一个模块的数据,或者直接转入另一个模块时，就发生了内容耦合。此时，被修改的模块完全依赖于修改它的模块。

　　　　　　eg.我觉得在js的经典问题“闭包”中，产生了内容耦合。

　　　　（2）公共耦合。两个以上的模块共同引用一个全局数据项就称为公共耦合。

　　　　　　eg.在以前写代码时，容易在全局定义一个变量，此时在不同的函数中使用这个变量，就产生了公共耦合。

　　　　（3）控制耦合。一个模块在界面上传递一个信号（如开关值、标志量等）控制另一个模块，接收信号的模块的动作根据信号值进行调整，称为控制耦合。

　　　　　　eg.经常我们会在代码中做一个flag进行标记此时的状态，当flag为0时执行部分代码，flag为1时执行另一部分代码，此时产生控制耦合。

　　　　（4）标记耦合。模块间通过参数传递复杂的内部数据结构，称为标记耦合。此数据结构的变化将使相关的模块发生变化。

　　　　　　eg.两个模块之间传递复杂的数据结构（例如对象），就产生了标记耦合。

　　　　（5）数据耦合。模块间通过参数传递基本类型的数据，称为数据耦合。

　　　　　　eg.两个模块之间传递简单的数据结构（例如number、boolean等），就产生了标记耦合。

　　　　（6）非直接耦合。模块间没有信息传递时，属于非直接耦合。

　　　　　　eg.我觉得和初始化init()函数类似，若其中代码毫无关联，则产生了非直接耦合。

 

以上就是我对内聚和耦合的理解。