精华内容
下载资源
问答
  • 2018-10-01 15:09:25

    在学校的时候就想好好汇总网上,软件开发程序猿英语学习的帖子了,IT行业英语还真是比较重要,还好没落下,自己平时也在学堂在线学习。
    下面纯属转载汇总,方便复习查找:

    IT软件开发常用英语词汇

    A
    abstract  抽象的
    
    abstract base class  抽象基类
    
    abstract class  抽象类
    
    abstraction  抽象、抽象物、抽象性
    
    access  存取、访问
    
    access function  访问函数
    
    access level  访问级别
    
    account  账户
    
    action  动作
    
    activate  激活
    
    actual parameter  实参
    
    adapter  适配器
    
    add-in  插件
    
    address  地址
    
    address space  地址空间
    
    ADO(ActiveX Data Object)  ActiveX数据对象
    
    advanced  高级的
    
    aggregation  聚合、聚集
    
    algorithm  算法
    
    alias  别名
    
    align  排列、对齐
    
    allocate  分配、配置
    
    allocator  分配器、配置器
    
    angle bracket  尖括号
    
    annotation  注解、评注
    
    API(Application Programming Interface)  应用(程序)编程接口
    
    appearance  外观
    
    append  附加
    
    application  应用、应用程序
    
    application framework  应用程序框架
    
    Approximate String Matching  模糊匹配
    
    architecture  架构、体系结构
    
    archive file  归档文件、存档文件
    
    argument  参数
    
    array  数组
    
    arrow operator  箭头操作符
    
    assert  断言
    
    assign  赋值
    
    assignment  赋值、分配
    
    assignment operator  赋值操作符
    
    associated  相关的、相关联的
    
    asynchronous  异步的
    
    attribute  特性、属性
    
    authentication service  验证服务
    
    authorization  授权
    
    B
    
    background  背景、后台
    
    backup  备份
    
    backup device  备份设备
    
    backup file  备份文件
    
    backward compatible  向下兼容
    
    base class  基类
    
    base type  基类型
    
    batch  批处理
    
    BCL(base class library)  基类库
    
    Bin Packing  装箱问题
    
    binary  二进制
    
    binding  绑定
    
    bit  位
    
    bitmap  位图
    
    block  块、区块、语句块
    
    boolean  布尔值
    
    border  边框
    
    bounds checking  边界检查
    
    boxing  装箱、装箱转换
    
    brace  大括号、花括号
    
    bracket  中括号、方括号
    
    breakpoint  断点
    
    browser applications  浏览器应用
    
    browser-accessible application  可经由浏览器访问的应用程序
    
    bug  缺陷错误
    
    build  编连(专指编译和链接)
    
    built-in  內建、内置
    
    bus  总线
    
    business  业务、商务
    
    business Logic  业务逻辑
    
    business rules  业务规则
    
    buttons  按钮
    
    by/through  通过
    
    byte  位单元
    
    C
    
    cache  告诉缓存
    
    calendar  日历
    
    Calendrical Calculations  日期
    
    call  调用
    
    call operator  调用操作符
    
    callback  回调
    
    candidate key  候选键
    
    cascading delete  级联删除
    
    cascading update  级联更新
    
    casting  转换、造型转换
    
    catalog  目录
    
    chain  链
    
    character  字符
    
    character format  字符格式
    
    character set  字符集
    
    check box  复选框
    
    check button  复选按钮
    
    CHECK constrains  CHECK约束
    
    checkpoint  检查点
    
    child class  子类
    
    class  类
    
    class declaration  类声明
    
    class definition  类定义
    
    class derivation list  类继承列表
    
    class factory  类厂
    
    class hierarchy  类层次结构
    
    class library  类库
    
    class loader  类装载器
    
    class template  类模板
    
    class template partial specializations  类模板部分特化
    
    classification  分类
    
    clause  子句
    
    cleanup  清理、清除
    
    client  客户、客户端
    
    client application  客户端应用程序
    
    client area  客户区
    
    client cursor  客户端游标
    
    client-server  客户机/服务器、客户端/服务器
    
    clipboard  剪贴板
    
    clone  克隆
    
    CLS(common language specification)  通用语言规范
    
    code access security  代码访问安全
    
    code page  代码页
    
    COFF(Common Object File Format)  通用对象文件格式
    
    collection  集合
    
    COM(Component Object Model)  组件对象模型
    
    combo box  组合框
    
    command line  命令行
    
    comment  注释
    
    commit  提交
    
    communication  通讯
    
    compatible  兼容
    
    compile time  编译期、编译时
    
    compiler  编译器
    
    component  组件
    
    composite index  复合索引、组合索引
    
    composite key  复合键、组合键
    
    composition  复合、组合
    
    concept  概念
    
    concrete  具体的
    
    concrete class  具体类
    
    concurrency  并发、并发机制
    
    configuration  配置、组态
    
    Connected Components  连通分支
    
    connection  连接
    
    connection pooling  连接池
    
    console  控制台
    
    constant  常量
    
    Constrained and Unconstrained Optimization  最值问题
    
    constraint  约束
    
    construct  构件、成分、概念、构造
    
    constructor  构造函数、构造器
    
    container  容器
    
    containment  包容
    
    context  环境、上下文
    
    control  控件
    
    copy  拷贝
    
    cover  覆盖、涵盖
    
    create/creation  创建、生成
    
    crosstab query  交叉表查询
    
    Cryptography  密码
    
    CTS(common type system)  通用类型系统
    
    cube  多维数据集
    
    cursor  光标、游标
    
    custom  定制、自定义
    
    D
    
    data  数据
    
    data connection  数据连接
    
    data dictionary  数据字典
    
    data file  数据文件
    
    data integrity  数据完整性
    
    data manipulation language(DML)  数据操作语言
    
    data member  数据成员、成员变量
    
    data source  数据源
    
    Data source name(DSN)  数据源名称
    
    data structure  数据结构
    
    Data Structures  基本数据结构
    
    data table  数据表
    
    data-bound  数据绑定
    
    database  数据库
    
    database catalog  数据库目录
    
    dtabase diagram  数据关系图
    
    database file  数据库文件
    
    database object  数据库对象
    
    database project  数据库工程
    
    database role  数据库角色
    
    database schema  数据库模式、数据库架构
    
    database script  数据库脚本
    
    datagram  数据报文
    
    dataset  数据集
    
    DBMS(database management system)  数据库管理系统
    
    DCOM(distributed COM)  分布式COM
    
    dead lock  死锁
    
    deallocate  归还
    
    debug  调试
    
    debugger  调试器
    
    decay  退化
    
    declaration  声明
    
    default  缺省、默认值
    
    DEFAULT constraint  默认约束
    
    default database  默认数据库
    
    default instance  默认实例
    
    default result set  默认结果集
    
    defer  推迟
    
    definition  定义
    
    delegate  委托
    
    delegation  委托
    
    deploy  部署
    
    derived class  派生类
    
    disign pattern  设计模式
    
    destroy  销毁
    
    destructor  析构函数、析构器
    
    device  设备
    
    DHTML(dynamic HyperText Markup Language)  动态超文本标记语言
    
    dialog  对话框
    
    Dictionaries  字典
    
    digest  摘要
    
    digital  数字的
    
    directive  指示符
    
    directory  目录
    
    disassembler  反编译器
    
    dispatch  调度、分派、派发
    
    distributed computing  分布式计算
    
    distributed query  分布式查询
    
    DNA(Distributed interNet Application)  分布式网间应用程序
    
    document  文档
    
    DOM(Document Object Model)  文档对象模型
    
    dot operator  点操作符
    
    double-byte character set  双字节字符集
    
    driver  驱动程序
    
    DTD(document type difinition)  文档类型定义
    
    dump  转储
    
    dump file  转储文件
    
    E
    
    e-business  电子商务
    
    efficiency  效率
    
    encapsulation  封装
    
    end user  最终用户
    
    end-to-end authentication  端对端身份验证
    
    engine  引擎
    
    entity  实体
    
    enum  枚举
    
    enumerators  枚举成员、枚举器
    
    equals  相等
    
    equality  相等性
    
    equality operator  等号操作符
    
    error log  错误日志
    
    escape character  转义符、转义字符
    
    escape code  转义码
    
    evaluate  评估
    
    event  事件
    
    event driven  事件驱动的
    
    event handler  事件处理器
    
    evidence  证据
    
    exception  异常
    
    exception declaration  异常声明
    
    exception handling  异常处理、异常处理机制
    
    exception specification  异常规范
    
    exception-safe  异常安全的
    
    exit  退出
    
    explicit  显式
    
    explicit specialization  显式特化
    
    explicit transaction  显式事务
    
    export  导出
    
    expression  表达式
    
    F
    
    fat client  胖客户端
    
    feature  特性、特征
    
    fetch  提取
    
    field  字段
    
    field length  字段长度
    
    file  文件
    
    filter  筛选
    
    finalization  终结
    
    finalizer  终结器
    
    firewall  防火墙 
    
    flag  标记
    
    flash memory  闪存
    
    flush  刷新
    
    font  字体
    
    foreign key  外键
    
    form  窗体
    
    fromal parameter  形参
    
    forward declaration  前置声明
    
    forward-only  只向前的
    
    forward-only cursor  只向前游标
    
    framework  框架
    
    full specialization  完全特化
    
    function  函数
    
    function call operator  函数调用操作符
    
    function object  函数对象
    
    function template  函数模板
    
    functionality  功能
    
    functor  仿函数
    
    G
    
    GC(Garbage collection)  垃圾回收机制、垃圾收集机制
    
    generate  生成
    
    generic  泛化的、一般化的、通用的
    
    generic algorithm  通用算法
    
    genericity  泛型
    
    getter  取值函数
    
    global  全局的
    
    global object  全局对象
    
    grant  授权
    
    group  组、群
    
    group box  分组框
    
    GUI  图形界面
    
    GUID(Globally Unique Identifier)  全球唯一标识符
    
    H
    
    handle  句柄
    
    handler  处理器
    
    hard disk  硬盘
    
    hard-coded  硬编码的
    
    hard-copy  截屏图
    
    hardware  硬件
    
    hash table  散列表、哈希表
    
    header file  头文件
    
    heap  堆
    
    help file  帮助文件
    
    hierarchical data  阶层式数据、层次式数据
    
    hierarchy  层次结构、继承体系
    
    high level  高阶、高层
    
    hook  钩子
    
    Host  宿主
    
    hot key  热键
    
    HTML  超文本标记语言
    
    HTTP  超文本传输协议
    
    HTTP pipeline  HTTP管道
    
    hyperlink  超链接
    
    I
    
    icon  图标
    
    IDE(Integreated Development Environment)  集成开发环境
    
    identifier  标识符
    
    IDL(Interface Definition Language)  接口定义语言
    
    idle time  空闲时间
    
    if and only if  当且仅当
    
    IL(Itermadiate Language)  中间语言、中介语言
    
    image  图像
    
    IME  输入法
    
    immediate base  直接基类
    
    immediate derived  直接派生类
    
    immediate updating  即时更新
    
    implement  实现
    
    implementation  实现、实现品
    
    implicit  隐式
    
    implicit transaction  隐式事务
    
    import  导入
    
    incremental update  增量更新
    
    Independent Set  独立集
    
    index  索引
    
    infinite loop  无限循环
    
    infinite recursive  无限递归
    
    information  信息
    
    inheritance  继承、继承机制
    
    initialization  初始化
    
    initialization list  初始化列表、初始值列表
    
    initialize  初始化
    
    inline  内联
    
    inline expansion  内联展开
    
    inner join  内连接
    
    instance  实例
    
    instantiated  具现化、实体化
    
    instantiation  具现化、具现化实体
    
    integrate  集成、整合
    
    integrity  完整性、一致性
    
    intetrity constraint  完整性约束
    
    interacts  交互
    
    interface  接口
    
    interoperability  互操作性、互操作能力
    
    interpreter  解释器
    
    introspection  自省
    
    invariants  不变性
    
    invoke  调用
    
    isolation level  隔离级别
    
    item  项、条款、项目
    
    iterate  迭代
    
    iteration  迭代
    
    iterative  反复的、迭代的
    
    iterator  迭代器
    
    J
    
    JIT compilation  JIT编译即时编译
    
    Job Scheduling  工程安排
    
    K
    
    key  键
    
    key colume  键列
    
    L
    
    left outer join  左向外连接
    
    level  阶、层例
    
    libaray  库
    
    lifetime  生命期、寿命
    
    Linear Programming  线性规划
    
    link  连接、链接
    
    linkage  连接、链接
    
    list  列表、表、链表
    
    list box  列表框
    
    literal constant  字面常数
    
    livelock  活锁
    
    load  装载、加载
    
    load balancing  负载平衡
    
    loader  装载器、载入器
    
    local  局部的
    
    local object  局部对象
    
    lock  锁
    
    log  日志
    
    login  登录
    
    login security mode  登录安全模式
    
    lookup table  查找表
    
    loop  循环
    
    loose coupling  松散耦合
    
    lvalue  左值
    
    M
    
    machine code  机器码、机器代码
    
    macro  宏
    
    maintain  维护
    
    managed code  受控代码、托管代码
    
    Managed Extensions  受控扩充件、托管扩展
    
    managed object  受控对象、托管对象
    
    manifest  清单
    
    many-to-many relationship  多对多关系
    
    many-to-one relationship  多对一关系
    
    marshal  列表
    
    Matching  匹配
    
    member  成员
    
    memeber access operator  成员取用运算子(有dot和arrow两种)
    
    memeber function  成员函数
    
    member initialization list  成员初始值列表
    
    memory  内存
    
    memory leak  内存泄漏
    
    menu  菜单
    
    message  消息
    
    message based  基于消息的
    
    message loop  消息环
    
    message queuing  消息队列
    
    metadata  元数据
    
    metaprogramming  元编程
    
    method  方法
    
    micro  微
    
    middle tier  中间层
    
    meddleware  中间件
    
    modeling  建模
    
    modeling language  建模语言
    
    modem  调制解调器
    
    modifier  修饰字、修饰符
    
    module  模块
    
    most derived class  最底层的派生类
    
    mouse  鼠标
    
    multi-tasking  多任务
    
    multi-thread  多线程
    
    multicase delegate  组播委托、多点委托
    
    multithreaded server application  多线程服务器应用程序
    
    multiuser  多用户
    
    multable  多变的
    
    mutex  互斥元、互斥体
    
    N
    
    named parameter  命名参数
    
    named pipe  命名管道
    
    namespace  命名空间
    
    native  原生的、本地的
    
    naive code  本地码、本机码
    
    nested class  嵌套类
    
    nested query  嵌套查询
    
    nested table  嵌套表
    
    network  网络
    
    network card  网卡
    
    Network Flow  网络流
    
    O
    
    object  对象
    
    object based  基于对象的
    
    object oriented  面向对象的
    
    ODBC data source  ODBC数据源
    
    ODBC driver  ODBC驱动程序
    
    one-to-many relationship  一对多关系
    
    ont-to-one relationship  一对一关系
    
    operating system  操作系统
    
    operation  操作
    
    operator  操作符、运算符
    
    option  选项
    
    outer join  外连接
    
    overflow  上限溢位
    
    overload  重载
    
    override  覆写、重载、重新定义
    
    P
    
    package  包
    
    packaging  打包
    
    palette  调色板
    
    parallel  并行
    
    parameter  参数、形式参数、形参
    
    parameter list  参数列表
    
    parameterize  参数化
    
    parent class  父类
    
    parentheses  圆括号
    
    parse  解析
    
    parser  解析器
    
    part  零件、部件
    
    partial specialization  局部特化
    
    pass by reference  引用传递
    
    pass by value  值传递
    
    pattern  模式
    
    persistence  持久性
    
    pixel  像素
    
    placeholder  占位符
    
    platform  平台
    
    Point Location  位置查询
    
    pointer  指针
    
    polymorphism  多态
    
    pooling  池化
    
    pop up  弹出式
    
    port  端口
    
    postfix  后缀
    
    precedence  优先序
    
    prefix  前缀
    
    preprocessor  预处理器
    
    primary key  主键
    
    primary table  主表
    
    primitive type  原始类型
    
    print  打印
    
    printer  打印机
    
    procedure  过程
    
    process  进程
    
    program  程序
    
    programmer  程序员
    
    programming  编程、程序设计
    
    progress bar  进度指示器
    
    project  项目、工程
    
    property  属性
    
    protocol  协议
    
    pseudo code  伪码
    
    Q
    
    qualified  合格的
    
    qualifier  修饰符
    
    quality  质量
    
    queue  队列
    
    R
    
    radio button  单选按钮
    
    random number  随机数
    
    Random Number Generation  随机数生成
    
    range  范围、区间
    
    rank  等级
    
    raw  未经处理的
    
    re-dirrection  重定向
    
    readOnly  只读
    
    record  记录
    
    recordset  记录集
    
    recursion  递归
    
    recursive  递归
    
    refactoring  重构
    
    refer  引用、参考
    
    reference  引用、参考
    
    reflection  反射
    
    refresh data  刷新数据
    
    registre  寄存器
    
    regular expression  正则表达式
    
    relational database  关系数据库
    
    remote  远程
    
    remote requset  远程请求
    
    represent  表述、表现
    
    resolution  解析过程
    
    resolve  解析、决议
    
    result set  结果集
    
    retrieve data  检索数据
    
    return  返回
    
    return type  返回类型
    
    return value  返回值
    
    revoke  撤销
    
    right outer join  右向外连接
    
    robust  健壮
    
    robustness  健壮性
    
    roll back  回滚
    
    roll forward  前滚
    
    routine  例程
    
    row  行
    
    rowset  行集
    
    RPC(remote procedure call)  RPC远程过程调用
    
    runtime  执行期、运行期、执行时、运行时
    
    rvalue  右值
    
    S
    
    Satisfiablity  可满足性
    
    save  保存
    
    savepoint  保存点
    
    SAX(Simple API for XML)
    
    scalable  可伸缩的、可扩展的
    
    schedule  调度
    
    scheduler  调度程序
    
    schema  模式、纲目结构
    
    scope  作用域、生存空间
    
    screen  屏幕
    
    scroll bar  滚动条
    
    SDK(sofeware delvelopment kit)  软件开发包
    
    sealed class  密封类
    
    search  查找
    
    Searching  查找
    
    semantics  语义
    
    sequential container  序列化容器
    
    serial  串行
    
    serialization/serialize  序列化
    
    server  服务器、服务端
    
    session  会话
    
    Set and String Problems  集合与串的问题
    
    Set Cover  集合覆盖
    
    Set Data Structures  集合
    
    Set Packing  集合配置
    
    setter  设值函数
    
    side effect  副作用
    
    signature  签名
    
    single-threaded  单线程
    
    slider  滑块
    
    slot  槽
    
    SMTP(Simple Mail Transfer Protocol)  简单邮件传输协议
    
    snapshot  截屏图
    
    snapshot  快照
    
    SOAP(simple object access protocol)  简单对象访问协议
    
    software  软件
    
    Sorting  排序
    
    source code  源码、源代码
    
    specialization  特化
    
    specification  规范、规格
    
    splitter  切分窗口
    
    SQL(Structured Query Language)  结构化查询语言
    
    stack  栈、堆栈
    
    standard library  标准库
    
    standard template library  标准模板库
    
    stateless  无状态的
    
    statement  语句、声明
    
    static cursor  静态游标
    
    static SQL statement  静态SQL语句
    
    status bar  状态条
    
    stored procedure  存储过程
    
    stream  流
    
    string  字符串
    
    String Matching  模式匹配
    
    stub  存根
    
    subobject  子对象
    
    subquery  子查询
    
    subscript operator  下标操作符
    
    support  支持
    
    suspend  挂起
    
    symbol  记号
    
    syntax  语法
    
    system databases  系统数据库
    
    system tables  系统表
    
    T
    
    table  表
    
    table-level constraint  表级约束
    
    target  目标
    
    task switch  工作切换
    
    TCP(transport control protocol)  传输控制协议
    
    template  模板
    
    temporary object  临时对象
    
    temporary table  临时表
    
    text  文本
    
    Text compression  压缩
    
    text file  文本文件
    
    thin client  瘦客户端
    
    third-party  第三方
    
    thread  线程
    
    thread-safe  线程安全的
    
    throw  抛出、引发
    
    trace  跟踪
    
    transaction  事务
    
    transaction log  事务日志
    
    transaction rollback  事务回滚
    
    traverse  遍历
    
    trigger  触发器
    
    type  类型
    
    U
    
    UML(unfied modeling language)  统一建模语言
    
    unary function  单参函数
    
    unary operator  一元操作符
    
    unboxing  拆箱、拆箱转换
    
    underflow  下限溢位
    
    Unicode  统一字符编码标准
    
    union query  联合查询
    
    unique constraints  unique约束
    
    unique index  唯一索引
    
    unmanaged code  非受控代码、非托管代码
    
    unmarshal  散集
    
    unqualified  未经限定的、未经修饰的
    
    URI(uniform resource identifier)  统一资源标识符
    
    URL(uniform resource locator)  统一资源定位器
    
    user  用户
    
    user interface  用户界面
    
    V
    
    value types  值类型
    
    variable  变量
    
    vector  向量
    
    vendor  厂商
    
    viable  可行的
    
    video  视频
    
    view  视图
    
    virtual function  虚函数
    
    virtual machine  虚拟机
    
    virtual memory  虚拟内存
    
    W
    
    web services   web服务
    
    where clause  where子句
    
    wildcard characters  通配符字符
    
    wildcard search  通配符搜索
    
    window  窗口
    
    window function  窗口函数
    
    window procedure  窗口过程
    
    windows authentication  window身份验证
    
    wizard  向导
    
    word  单词
    
    write enable  写启用
    
    write-only  只写
    
    WSDL(web service description language)  service描述语言
    
    X
    
    XML(eXtensible Markup Language)  可扩展标记语言
    
    XML Message Interface  XML消息接口
    
    XSD(XML Schema Definition)  XML模式定义语言
    
    XSL(eStensible Stylesheet Language)  可扩展样式表语言
    
    XSLT(eXtensible Stylesheet Language Transformation)  可扩展样式表语言转换
    

    程序员必须掌握的600个英语单词

    application 应用程式 应用、应用程序
    application framework 应用程式框架、应用框架 应用程序框架
    architecture 架构、系统架构 体系结构
    argument 引数(传给函式的值)。叁见 parameter 叁数、实质叁数、实叁、自变量
    array 阵列 数组
    arrow operator arrow(箭头)运算子 箭头操作符
    assembly 装配件
    assembly language 组合语言 汇编语言
    assert(ion) 断言
    assign 指派、指定、设值、赋值 赋值
    assignment 指派、指定 赋值、分配
    assignment operator 指派(赋值)运算子 = 赋值操作符
    associated 相应的、相关的 相关的、关联、相应的
    associative container 关联式容器(对应 sequential container) 关联式容器
    atomic 不可分割的 原子的
    attribute 属性 属性、特性
    audio 音讯 音频
    A.I. 人工智慧 人工智能
    background 背景 背景(用於图形着色) 后台(用於行程)
    backward compatible 回溯相容 向下兼容
    bandwidth 频宽 带宽
    base class 基础类别 基类
    base type 基础型别 (等同於 base class)
    batch 批次(意思是整批作业) 批处理
    benefit 利益 收益
    best viable function 最佳可行函式 最佳可行函式 (从 viable functions 中挑出的最佳吻合者)
    binary search 二分搜寻法 二分查找
    binary tree 二元树 二叉树
    binary function 二元函式 双叁函数
    binary operator 二元运算子 二元操作符
    binding 系结 绑定
    bit 位元 位
    bit field 位元栏 位域
    bitmap 位元图 位图
    bitwise 以 bit 为单元逐一┅
    bitwise copy 以 bit 为单元进行复制;位元逐一复制 位拷贝
    block 区块,区段 块、区块、语句块
    boolean 布林值(真假值,true 或 false) 布尔值
    border 边框、框线 边框
    brace(curly brace) 大括弧、大括号 花括弧、花括号
    bracket(square brakcet) 中括弧、中括号 方括弧、方括号
    breakpoint 中断点 断点
    build 建造、构筑、建置(MS 用语)
    build-in 内建 内置
    bus 汇流排 总线
    business 商务,业务 业务
    buttons 按钮 按钮
    byte 位元组(由 8 bits 组成) 字节
    cache 快取 高速缓存
    call 呼叫、叫用 调用
    callback 回呼 回调
    call operator call(函式呼叫)运算子调用操作符 ###### (同 function call operator)
    candidate function 候选函式 候选函数 ###### (在函式多载决议程序中出现的候选函式)
    chain 串链(例 chain of function calls) 链
    character 字元 字符
    check box 核取方块 (i.e. check button) 复选框
    checked exception 可控式异常(Java)
    check button 方钮 (i.e. check box) 复选按钮
    child class 子类别(或称为derived class, subtype) 子类
    class 类别 类
    class body 类别本体 类体
    class declaration 类别宣告、类别宣告式 类声明
    class definition 类别定义、类别定义式 类定义
    class derivation list 类别衍化列 类继承列表
    class head 类别表头 类头
    class hierarchy 类别继承体系, 类别阶层 类层次体系
    class library 类别程式库、类别库 类库
    class template 类别模板、类别范本 类模板
    class template partial specializations ###### 类别模板偏特化 类模板部分特化
    class template specializations ###### 类别模板特化 类模板特化
    cleanup 清理、善后 清理、清除
    client 客端、客户端、客户 客户
    client-server 主从架构 客户/服务器
    clipboard 剪贴簿 剪贴板
    clone 复制 克隆
    collection 群集 集合
    combo box 复合方块、复合框 组合框
    command line 命令列 命令行 (系统文字模式下的整行执行命令)
    communication 通讯 通讯
    compatible 相容 兼容
    compile time 编译期 编译期、编译时
    compiler 编译器 编译器
    component 组件 组件
    composition 复合、合成、组合 组合
    computer 电脑、计算机 计算机、电脑
    concept 概念 概念
    concrete 具象的 实在的
    concurrent 并行 并发
    configuration 组态 配置
    connection 连接,连线(网络,资料库) 连接
    constraint 约束(条件)
    construct 构件 构件
    container 容器 容器 ###### (存放资料的某种结构如 list, vector…)
    containment 内含 包容
    context 背景关系、周遭环境、上下脉络 环境、上下文
    control 控制元件、控件 控件
    console 主控台 控制台
    const 常数(constant 的缩写,C++ 关键字)
    constant 常数(相对於 variable) 常量
    constructor(ctor) 建构式 构造函数 ###### (与class 同名的一种 member functions)
    copy (v) 复制、拷贝 拷贝
    copy (n) 复件, 副本
    cover 涵盖 覆盖
    create 创建、建立、产生、生成 创建
    creation 产生、生成 创建
    cursor 游标 光标
    custom 订制、自定 定制
    data 资料 数据
    database 资料库 数据库
    database schema 数据库结构纲目
    data member 资料成员、成员变数 数据成员、成员变量
    data structure 资料结构 数据结构
    datagram 资料元 数据报文
    dead lock 死结 死锁
    debug 除错 调试
    debugger 除错器 调试器
    declaration 宣告、宣告式 声明
    deduction 推导(例:template argument deduction) 推导、推断
    default 预设 缺省、默认
    defer 延缓 推迟
    define 定义 预定义
    definition 定义、定义区、定义式 定义
    delegate 委派、委托、委任 委托
    delegation (同上)
    demarshal 反编列 散集
    dereference 提领(取出指标所指物体的内容) 解叁考
    dereference operator dereference(提领)运算子 * 解叁考操作符
    derived class 衍生类别 派生类
    design by contract 契约式设计
    design pattern 设计范式、设计样式 设计模式 ※ 最近我比较喜欢「设计范式」一词
    destroy 摧毁、销毁
    destructor 解构式 析构函数
    device 装置、设备 设备
    dialog 对话窗、对话盒 对话框
    directive 指令(例:using directive) (编译)指示符
    directory 目录 目录
    disk 碟 盘
    dispatch 分派 分派
    distributed computing 分布式计算 (分布式电算) 分布式计算 分散式计算 (分散式电算)
    document 文件 文档
    dot operator dot(句点)运算子 . (圆)点操作符
    driver 驱动程式 驱动(程序)
    dynamic binding 动态系结 动态绑定
    efficiency 效率 效率
    efficient 高效 高效
    end user 终端用户
    entity 物体 实体、物体
    encapsulation 封装 封装
    enclosing class 外围类别(与巢状类别 nested class 有关)外围类
    enum (enumeration) 列举(一种 C++ 资料型别) 枚举
    enumerators 列举元(enum 型别中的成员) 枚举成员、枚举器
    equal 相等 相等
    equality 相等性 相等性
    equality operator equality(等号)运算子 == 等号操作符
    equivalence 等价性、等同性、对等性 等价性
    equivalent 等价、等同、对等 等价
    escape code 转义码 转义码
    evaluate 评估、求值、核定 评估
    event 事件 事件
    event driven 事件驱动的 事件驱动的
    exception 异常情况 异常
    exception declaration 异常宣告(ref. C++ Primer 3/e, 11.3) 异常声明
    exception handling 异常处理、异常处理机制 异常处理、异常处理机制
    exception specification 异常规格(ref. C++ Primer 3/e, 11.4) 异常规范
    exit 退离(指离开函式时的那一个执行点) 退出
    explicit 明白的、明显的、显式 显式
    export 汇出 引出、导出
    expression 运算式、算式 表达式
    facility 设施、设备 设施、设备
    feature 特性
    field 栏位,资料栏(Java) 字段, 值域(Java)
    file 档案 文件
    firmware 韧体 固件
    flag 旗标 标记
    flash memory 快闪记忆体 闪存
    flexibility 弹性 灵活性
    flush 清理、扫清 刷新
    font 字型 字体
    form 表单(programming 用语) 窗体
    formal parameter 形式叁数 形式叁数
    forward declaration 前置宣告 前置声明
    forwarding 转呼叫,转发 转发
    forwarding function 转呼叫函式,转发函式 转发函数
    fractal 碎形 分形
    framework 框架 框架
    full specialization 全特化(ref. partial specialization)
    function 函式、函数 函数
    function call operator 同 call operator
    function object 函式物件(ref. C++ Primer 3/e, 12.3) 函数对象
    function overloaded resolution 函式多载决议程序 函数重载解决(方案)
    functionality 功能、机能 功能
    function template 函式模板、函式范本 函数模板
    functor 仿函式 仿函式、函子
    game 游戏 游戏
    generate 生成
    generic 泛型、一般化的 一般化的、通用的、泛化
    generic algorithm 泛型演算法 通用算法
    getter (相对於 setter) 取值函式
    global 全域的(对应於 local) 全局的
    global object 全域物件 全局对象
    global scope resolution operator 全域生存空间(范围决议)运算子 :: 全局范围解析操作符
    group 群组
    group box 群组方块 分组框
    guard clause 卫述句 (Refactoring, p250) 卫语句
    GUI 图形介面 图形界面
    hand shaking 握手协商
    handle 识别码、识别号、号码牌、权柄 句柄
    handler 处理常式 处理函数
    hard-coded 编死的 硬编码的
    hard-copy 硬拷图 屏幕截图
    hard disk 硬碟 硬盘
    hardware 硬体 硬件
    hash table 杂凑表 哈希表、散列表
    header file 表头档、标头档 头文件
    heap 堆积 堆
    hierarchy 阶层体系 层次结构(体系)
    hook 挂钩 钩子
    hyperlink 超链结 超链接
    icon 图示、图标 图标
    IDE 整合开发环境 集成开发环境
    identifier 识别字、识别符号 标识符
    if and only if 若且唯若 当且仅当
    Illinois 伊利诺 伊利诺斯
    image 影像 图象
    immediate base 直接的(紧临的)上层 base class。 直接上层基类
    immediate derived 直接的(紧临的)下层 derived class。 直接下层派生类
    immutability 不变性
    immutable 不可变(的)
    implement 实作、实现 实现
    implementation 实作品、实作体、实作码、实件 实现
    implicit 隐喻的、暗自的、隐式 隐式
    import 汇入 导入
    increment operator 累加运算子 ++ 增加操作符
    infinite loop 无穷回圈 无限循环
    infinite recursive 无穷递回 无限递归
    information 资讯 信息
    infrastructure 公共基础建设
    inheritance 继承、继承机制 继承、继承机制
    inline 行内 内联
    inline expansion 行内展开 内联展开
    initialization 初始化(动作) 初始化
    initialization list 初值列 初始值列表
    initialize 初始化 初始化
    inner class 内隐类别 内嵌类
    instance 实体 实例 ###### (根据某种表述而实际产生的「东西」)
    instantiated 具现化、实体化(常应用於 template) 实例化
    instantiation 具现体、具现化实体(常应用於 template) 实例
    integer (integral) 整数(的) 整型(的)
    integrate 整合 集成
    interacts 交谈、互动 交互
    interface 介面 接口
    for GUI 介面 界面
    interpreter 直译器 解释器
    invariants 恒常性,约束条件 约束条件
    invoke 唤起 调用
    iterate 迭代(回圈一个轮回一个轮回地进行) 迭代
    exception 异常情况 异常
    exception declaration 异常宣告(ref. C++ Primer 3/e, 11.3) 异常声明
    exception handling 异常处理、异常处理机制 异常处理、异常处理机制
    exception specification 异常规格(ref. C++ Primer 3/e, 11.4) 异常规范
    exit 退离(指离开函式时的那一个执行点) 退出
    explicit 明白的、明显的、显式 显式
    export 汇出 引出、导出
    expression 运算式、算式 表达式
    facility 设施、设备 设施、设备
    feature 特性
    field 栏位,资料栏(Java) 字段, 值域(Java)
    file 档案 文件
    firmware 韧体 固件
    flag 旗标 标记
    flash memory 快闪记忆体 闪存
    flexibility 弹性 灵活性
    flush 清理、扫清 刷新
    font 字型 字体
    form 表单(programming 用语) 窗体
    formal parameter 形式叁数 形式叁数
    forward declaration 前置宣告 前置声明
    forwarding 转呼叫,转发 转发
    forwarding function 转呼叫函式,转发函式 转发函数
    fractal 碎形 分形
    framework 框架 框架
    full specialization 全特化(ref. partial specialization)
    function 函式、函数 函数
    function call operator 同 call operator
    function object 函式物件(ref. C++ Primer 3/e, 12.3) 函数对象
    function overloaded resolution 函式多载决议程序 函数重载解决(方案)
    functionality 功能、机能 功能
    function template 函式模板、函式范本 函数模板
    functor 仿函式 仿函式、函子
    game 游戏 游戏
    generate 生成
    generic 泛型、一般化的 一般化的、通用的、泛化
    generic algorithm 泛型演算法 通用算法
    getter (相对於 setter) 取值函式
    global 全域的(对应於 local) 全局的
    global object 全域物件 全局对象
    global scope resolution operator 全域生存空间(范围决议)运算子 :: 全局范围解析操作符
    group 群组
    group box 群组方块 分组框
    guard clause 卫述句 (Refactoring, p250) 卫语句
    GUI 图形介面 图形界面
    hand shaking 握手协商
    handle 识别码、识别号、号码牌、权柄 句柄
    handler 处理常式 处理函数
    hard-coded 编死的 硬编码的
    hard-copy 硬拷图 屏幕截图
    hard disk 硬碟 硬盘
    hardware 硬体 硬件
    hash table 杂凑表 哈希表、散列表
    header file 表头档、标头档 头文件
    heap 堆积 堆
    hierarchy 阶层体系 层次结构(体系)
    hook 挂钩 钩子
    hyperlink 超链结 超链接
    icon 图示、图标 图标
    IDE 整合开发环境 集成开发环境
    identifier 识别字、识别符号 标识符
    if and only if 若且唯若 当且仅当
    Illinois 伊利诺 伊利诺斯
    image 影像 图象
    immediate base 直接的(紧临的)上层 base class。 直接上层基类
    immediate derived 直接的(紧临的)下层 derived class。 直接下层派生类
    immutability 不变性
    immutable 不可变(的)
    implement 实作、实现 实现
    implementation 实作品、实作体、实作码、实件 实现
    implicit 隐喻的、暗自的、隐式 隐式
    import 汇入 导入
    increment operator 累加运算子 ++ 增加操作符
    infinite loop 无穷回圈 无限循环
    infinite recursive 无穷递回 无限递归
    information 资讯 信息
    infrastructure 公共基础建设
    inheritance 继承、继承机制 继承、继承机制
    inline 行内 内联
    inline expansion 行内展开 内联展开
    initialization 初始化(动作) 初始化
    initialization list 初值列 初始值列表
    initialize 初始化 初始化
    inner class 内隐类别 内嵌类
    instance 实体 实例 ###### (根据某种表述而实际产生的「东西」)
    instantiated 具现化、实体化(常应用於 template) 实例化
    instantiation 具现体、具现化实体(常应用於 template) 实例
    integer (integral) 整数(的) 整型(的)
    integrate 整合 集成
    interacts 交谈、互动 交互
    interface 介面 接口
    for GUI 介面 界面
    interpreter 直译器 解释器
    invariants 恒常性,约束条件 约束条件
    invoke 唤起 调用
    iterate 迭代(回圈一个轮回一个轮回地进行) 迭代
    iterative 反覆的,迭代的
    iterator 迭代器(一种泛型指标) 迭代器
    iteration 迭代(回圈每次轮回称为一个 iteration) 迭代
    item 项目、条款 项、条款、项目
    laser 雷射 激光
    level 阶 层 (级) 例 high level 高阶 高层
    library 程式库、函式库 库、函数库
    lifetime 生命期、寿命 生命期、寿命
    link 联结、连结 连接,链接
    linker 联结器、连结器 连接器
    literal constant 字面常数(例 3.14 或 “hi” 这等常数值) 字面常数
    list 串列(linked-list) 列表、表、链表
    list box 列表方块、列表框 列表框
    load 载入 装载
    loader 载入器 装载器、载入器
    local 区域的(对应於 global) 局部的
    local object 区域物件 局部对象
    lock 机锁
    loop 回圈 循环
    lvalue 左值 左值
    macro 巨集 宏
    magic number 魔术数字 魔法数
    maintain 维护 维护
    manipulator 操纵器(iostream 预先定义的一种东西) 操纵器
    marshal 编列 列集 叁考 demarshal
    mechanism 机制 机制
    member 成员 成员
    member access operator 成员取用运算子(有 dot 和 arrow 两种) 成员存取操作符
    member function 成员函式 成员函数
    member initialization list 成员初值列 成员初始值列表
    memberwise 以 member 为单元┅、members 逐一┅ 以成员为单位
    memberwise copy 以 members 为单元逐一复制
    memory 记忆体 内存
    menu 表单、选单 菜单
    message 讯息 消息
    message based 以讯息为基础的 基於消息的
    message loop 讯息回圈 消息环
    method (java) 方法、行为、函式 方法
    meta- 超- 元- 例 meta-programming 超编程 元编程
    micro 微 微
    middleware 中介层 中间件
    modeling 模塑
    modeling language 塑模语言,建模语言
    modem 数据机 调制解调器
    module 模组 模块
    modifier 饰词 修饰符
    most derived class 最末层衍生类别 最底层的派生类
    mouse 滑鼠 鼠标
    mutable 可变的 可变的
    multi-tasking 多工 多任务
    namespace 命名空间 名字空间、命名空间
    native 原生的 本地的、固有的
    nested class 巢状类别 嵌套类
    network 网路 网络
    network card 网路卡 网卡
    object 物件 对象
    object based 以物件为基础的 基於对象的
    object file 目的档 目标文件
    object model 物件模型 对象模型
    object oriented 物件导向的 面向对象的
    online 线上 在线
    opaque 不透明的
    operand 运算元 操作数
    operating system (OS) 作业系统 操作系统
    operation 操作、操作行为 操作
    operator 运算子 操作符、运算符
    option 选项,可选方案 选项
    ordinary 常规的 常规的
    overflow 上限溢位(相对於 underflow) 溢出(underflow:下溢)
    overhead 额外负担、额外开销 额外开销
    overload 多载化、多载化、重载 重载
    overloaded function 多载化函式 重载的函数
    overloaded operator 多载化运算子 被重载的操作符
    overloaded set 多载集合 重载集合
    override 改写、覆写 重载、改写、重新定义 ###### (在 derived class 中重新定义虚拟函式
    package 套件 包
    pair 对组
    palette 调色盘、组件盘、工具箱
    pane 窗格 窗格 ###### (有时为嵌板之意,例 Java Content Pane)
    parallel 平行 并行
    parameter 叁数(函式叁数列上的变数) 叁数、形式叁数、形叁
    parameter list 叁数列 叁数列表
    parent class 父类别(或称 base class) 父类
    parentheses 小括弧、小括号 圆括弧、圆括号
    parse 解析 解析
    part 零件 部件
    partial specialization 偏特化(ref. C++ Primer 3/e, 16.10) 局部特化 ###### (ref. full specialization)
    pass by address 传址(函式引数的传递方式)(非正式用语)传地址
    pass by reference 传址(函式引数的一种传递方式) 传地址, 按引用传递
    pass by value 传值(函式引数的一种传递方式) 按值传递
    pattern 范式、样式 模式
    performance 效率、性能兼而有之 性能
    persistence 永续性 持久性
    pixel 图素、像素 像素
    placement delete ref. C++ Primer 3/e, 15.8.2
    placement new ref. C++ Primer 3/e, 15.8.2
    platform 平台 平台
    pointer 指标 指针 址位器(和址叁器 reference 形成对映,满好)
    poll 轮询 轮询
    polymorphism 多型 多态
    pop up 冒起式、弹出式 弹出式
    port 埠 端口
    postfix 后置式、后序式 后置式
    precedence 优先序(通常用於运算子的优先执行次序)
    prefix 前置式、前序式 前置式
    preprocessor 前处理器 预处理器
    prime 质数 素数
    primitive type 基本型别 (不同於 base class,基础类别)
    print 列印 打印
    printer 印表机 打印机
    priority 优先权 (通常用於执行绪获得 CPU 时间的优先次序)
    procedure 程序 过程
    procedural 程序性的、程序式的 过程式的、过程化的
    process 行程 进程
    profile 评测 评测
    profiler 效能(效率)评测器 效能(性能)评测器
    programmer 程式员 程序员
    programming 编程、程式设计、程式化 编程
    progress bar 进度指示器 进度指示器
    project 专案 项目、工程
    property 属性
    protocol 协定 协议
    pseudo code 假码、虚拟码、伪码 伪码
    qualified 经过资格修饰(例如加上 scope 运算子) 限定
    qualifier 资格修饰词、饰词 限定修饰词
    quality 品质 质量
    queue 伫列 队列
    radian 径度 弧度
    radio button 圆钮 单选按钮
    raise 引发(常用来表示发出一个 exception) 引起、引发
    random number 随机数、乱数 随机数
    range 范围、区间(用於 STL 时) 范围、区间
    rank 等级、分等(ref. C++Primer 3/e 9,15章) 等级
    raw 生鲜的、未经处理的 未经处理的
    record 记录 记录
    recordset 记录集 记录集
    recursive 递回 递归
    re-direction 重导向 重定向
    refactoring 重构、重整 重构
    refer 取用 叁考
    refer to 指向、指涉、指代
    reference (C++ 中类似指标的东西,相当於 “化身”) 引用、叁考 址叁器, see pointer
    register 暂存器 寄存器
    reflection 反射 反射、映像
    relational database 关联式资料库 关系数据库
    represent 表述,表现 表述,表现
    resolve 决议(为算式中的符号名称寻找 解析 对应之宣告式的过程)
    resolution 决议程序、决议过程 解析过程
    resolution 解析度 分辨率
    restriction 局限
    return 传回、回返 返回
    return type 回返型别 返回类型
    return value 回返值 返回值
    robust 强固、稳健 健壮
    robustness 强固性、稳健性 健壮性
    routine 常式 例程
    runtime 执行期 运行期、运行时
    common language runtime (CLR) 译为「通用语言执行层」
    rvalue 右值 右值
    save 储存 存储
    schedule 排程 调度
    scheduler 排程器 调度程序
    scheme 结构纲目、组织纲目
    scroll bar 卷轴 滚动条
    scope 生存空间、生存范围、范畴、作用域 生存空间
    scope operator 生存空间(范围决议)运算子 :: 生存空间操作符
    scope resolution operator 生存空间决议运算子 生存空间解析操作符 ###### (与scope operator同)
    screen 萤幕 屏幕
    search 搜寻 查找
    semantics 语意 语义
    sequential container 序列式容器 顺序式容器 ###### (对应於 associative container)
    server 伺服器、伺服端 服务器、服务端
    serial 串行
    serialization 次第读写,序列化 序列化 (serialize)
    setter (相对於 getter) 设值函式
    signal 信号
    signature 标记式、签名式、署名式 签名
    slider 滚轴 滑块
    slot 条孔、槽 槽
    smart pointer 灵巧指标、精灵指标 智能指针
    snapshot 萤幕快照(图) 屏幕截图
    specialization 特殊化、特殊化定义、特殊化宣告 特化
    specification 规格 规格、规范
    splitter 分裂视窗 切分窗口
    software 软体 软件
    solution 解法,解决方案 方案
    source 原始码 源码、源代码
    stack 堆叠 栈
    stack unwinding 堆叠辗转开解(此词用於 exception 主题) 栈辗转开解 *
    standard library 标准程式库
    standard template library 标准模板程式库
    statement 述句 语句、声明
    status bar 状态列、状态栏 状态条
    STL 见 standard template library
    stream 资料流、串流 流
    string 字串 字符串
    subroutine
    subscript operator 下标运算子 [ ] 下标操作符
    subtype 子型别 子类型
    support 支援 支持
    suspend 虚悬 挂起
    symbol 符号 记号
    syntax 语法 语法
    tag 标签 标记 索引标签,页签
    target 标的(例 target pointer:标的指标) 目标
    task switch 工作切换 任务切换
    template 模板、范本 模板
    template argument deduction 模板引数推导 模板叁数推导
    template explicit specialization 模板显式特化(版本) 模板显式特化
    template parameter 模板叁数 模板叁数
    temporary object 暂时物件 临时对象
    text 文字 文本
    

    软件开发中常见英文缩写和各类软件开发文档的英文缩写

    英文简写文档名称
    
    MRD market requirement document (市场需求文档)
    
    PRD product requirement document (产品需求文档)
    
    SOW 工作任务说明书
    PHB Process Handbook (项目过程手册)
    
    EST Estimation Sheet (估计记录)
    
    PPL Project Plan (项目计划)
    
    CMP Software Management Plan( 配置管理计划)
    
    QAP Software Quality Assurance Plan (软件质量保证计划)
    
    RMP Software Risk Management Plan (软件风险管理计划)
    
    TST Test Strategy(测试策略)
     
    WBS Work Breakdown Structure (工作分解结构)
    
    BRS Business Requirement Specification(业务需求说明书)
    
    SRS Software Requirement Specification(软件需求说明书)
    
    STP System Testing plan (系统测试计划)
    
    STC System Testing Cases (系统测试用例)
    
    HLD High Level Design (概要设计说明书)
    
    ITP Integration Testing plan (集成测试计划)
    
    ITC Integration Testing Cases (集成测试用例)
    
    LLD Low Level Design (详细设计说明书)
    
    UTP Unit Testing Plan ( 单元测试计划)
    
    UTC Unit Testing Cases (单元测试用例)
    
    UTR Unit Testing Report (单元测试报告)
    
    ITR Integration Testing Report (集成测试报告)
    
    STR System Testing Report (系统测试报告)
    
    RTM Requirements Traceability Matrix (需求跟踪矩阵)
    
    CSA Configuration Status Accounting (配置状态发布)
    
    CRF Change Request Form (变更申请表)
    
    WSR Weekly Status Report (项目周报)
    
    QSR Quality Weekly Status Report (质量工作周报)
    
    QAR Quality Audit Report(质量检查报告)
    
    QCL Quality Check List(质量检查表)
    
    PAR Phase Assessment Report (阶段评估报告)
    
    CLR Closure Report (项目总结报告)
    
    RFF Review Finding Form (评审发现表)
    
    MOM Minutes of Meeting (会议纪要)
    
    MTX Metrics Sheet (度量表)
    
    CCF ConsistanceCheckForm(一致性检查表)
     
    BAF Baseline Audit Form(基线审计表)
    
    PTF Program Trace Form(问题跟踪表)
    

    转自:

    1、https://www.cnblogs.com/anni-qianqian/p/5618693.html
    2、https://www.cnblogs.com/hdic/p/5996282.html
    3、https://www.cnblogs.com/chjbbs/p/6064465.html

    更多相关内容
  • 根据希蒙得木本身的生物生态学特性,结合川西南攀枝花和凉山州地区的气候特点,应用Fuzzy数学的相似优先比方法,提出了在该区20个市县引种发展希蒙得木的区域划分。拟划出适宜种植区、试验种植区和非种植区。为本...
  • 前端组件化开发实践总结

    千次阅读 多人点赞 2021-10-13 12:46:52
    自从 2010 年第一份工作接触了前后端半分离的开发方式之后,在后面的这些年里,对前端的组件化开发有了更全面一点的认识,组件化在我们的前端开发中,对提高开发效率、代码的可维护性和可复用性有很大帮助,甚至对跟...

    自从 2010 年第一份工作接触了前后端半分离的开发方式之后,在后面的这些年里,对前端的组件化开发有了更全面一点的认识,组件化在我们的前端开发中,对提高开发效率、代码的可维护性和可复用性有很大帮助,甚至对跟设计师沟通的效率和企业的品牌形象都有着深刻的影响。这篇文章就把我在开发中总结的一些组件化开发经验分享一下。示例中的所有代码都是伪代码,你可以按照实际情况应用到 React 或 Vue 的项目中。

    前端组件化发展历史

    在讨论组件化开发之前,我们先看看前端组件化开发的发展历史。网页开发刚起步时,并没有『前端』这个概念,更不用提组件化了。当时,网页只是作为可以在浏览器中浏览的富文本文件,开发网页就是使用一些标签让浏览器解析并显示。受制于 HTML 只是描述式的语言,网页中的代码没有办法复用,即使是类似的页面,都需要复制粘贴大量的重复代码:

    <!-- index.html -->
    <nav>
      <!-- 导航 -->
    </nav>
    <main>
      <!-- 内容 -->
    </main>
    <footer>
      <!-- 页脚 -->
    </footer>
    
    <!-- blogPost.html -->
    <nav>
      <!-- 相同的导航 -->
    </nav>
    <main>
      <!-- 不同的内容 -->
    </main>
    <footer>
      <!-- 相同的页脚 -->
    </footer>
    

    后来随着模板引擎的出现,可以把网页的代码分割成片段(Fragments)或模板(Templates),例如导航,内容,页脚等等,之后在需要的地方,使用引入(Include)语法,把这些片段引入进来,从而避免重复代码,这样形成了组件化的雏形,常见的动态脚本语言都有自己的模板引擎,例如 PHP、ASP 和 JSP:

    <!-- nav.jsp -->
    <nav>
      <!-- 导航 -->
    </nav>
    
    <!-- index.jsp -->
    <jsp:include page="nav.jsp" />
    

    只是这些片段在数据管理方面仍然会比较麻烦,还是需要使用客户端 JavaScript 脚本,手动控制数据和 HTML 视图的同步。而对于样式,也还是存在全局污染的问题。
    再后来,有些高级的开发语言,例如 Java, 推出了基于服务器的组件化开发技术,例如 JSF (JSP 的后继),基于 MVC 设计模式,通过 Java Class (POJO) 定义数据模型(Model),为 JSF 页面模板提供数据。JSF 的数据模型中有事件和生命周期相关的方法,而模板和数据模型通信的方式是 Ajax,通过使用 JSF facelets 组件的方式,可以直接发送 Ajax 请求,调用模型中的方法:

    <!-- index.xhtml -->
    <html
      xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html"
      xmlns:f="http://xmlns.jcp.org/jsf/core"
    >
      <h:commandButton id="submit" value="Submit">
        <f:ajax event="click" />
      </h:commandButton>
      <h:outputText id="result" value="#{userNumberBean.response}" />
    </html>
    
    // UserNumberBean.java
    @Named
    @RequestScoped
    public class UserNumberBean implements Serializable {
    	/* 其它代码省略 */
    
        public String getResponse() {
            if ((userNumber != null)
                    && (userNumber.compareTo(dukesNumberBean.getRandomInt()) == 0)) {
                return "Yay! You got it!";
            }
            if (userNumber == null) {
                return null;
            } else {
                return "Sorry, " + userNumber + " is incorrect.";
            }
        }
    }
    
    

    代码来源:Jarkarta EE 官方示例
    不过这种方式严格限定了编程语言,例如要用 JSF 技术就必须要使用 Java,并且样式污染的问题和客户端数据管理的问题仍然没有解决。
    随着 Node.js 的普及,JavaScript 可以脱离浏览器运行了,并且带来了 npm 包管理器,基于 npm 庞大的工具链,可以 Node.js 的代码打包成浏览器中能够运行的代码。而这期间,产生了像 React、Vue 和 Angular 这样的、适合大型前端项目开发的库和框架。

    在这里插入图片描述

    React 和 Vue 目前的流行程度比较高一些,它们都是纯客户端的、组件化的 JS 库,不依赖任何后端编程语言,让程序员都能够快速上手。不过,随着项目规模的扩大,如何利用好这些库进行组件化开发,成了前端工程师必须要掌握的课题。

    什么是组件

    那么到底什么是组件呢?你想一下日常生活中,电脑上的硬件,例如显卡、内存、CPU,或者汽车的零部件:轮胎、发动机、方向盘等,这些都属于组件,它们组合起来能形成一个完整可用的产品,对于遵循了设计规范的组件,只要型号匹配,无论品牌、样式,都可以互相兼容。
    我们前端工程师其实就当于是一个工厂,我们需要按照一定的规范,产生出合格的网页组件,利用它们组装成完整的页面。组件一般包含 HTML 模板、CSS 样式和 JavaScript 数据逻辑,自成一体,可以直接在其它组件中使用,组件本身的模板、样式和数据不会影响到其它组件。组件还包含一系列可配置的属性,动态的产生内容。

    常见的基础组件有按钮、导航、提示框、表单输入控件、对话框、表格、列表等,我们在它们的基础上又能组合出更复杂的组件,那么对于前端中的组件的定义就非常广泛了,小到一个按钮,大到一个页面都可以形成一个组件,例如两个相似的页面,可以复用一个页面组件,只需要通过修改组件的属性,来形成一个新的页面。

    在这里插入图片描述

    为什么要组件化开发

    你可能也知道,React 和 Vue 其实也可以完全按照传统的网页开发方式进行开发,最多是把网页大体分成几个部分,放到单独的几个文件里就好了,对于简单的网站来说没什么问题,但是如果开发的是大型的应用,例如网页版的 QQ 音乐、微信、邮箱等,它们有大量的、细小的组件,并且重复出现,这时如果针对每个页面编写 HTML 和样式,那么就会造成太多冗余代码了。

    <!-- playlist.html -->
    <div class="card">
      <div class="card__title"></div>
      <div class="card_content"></div>
    </div>
    
    <!-- homepage.html -->
    <div class="card">
      <div class="card__title"></div>
      <div class="card_content"></div>
    </div>
    
    <!-- user.html -->
    <div class="card">
      <div class="card__title"></div>
      <div class="card_content"></div>
    </div>
    

    如果使用组件化的方式,我们可以把重复出现的页面内容定义成组件,这样就不用复制粘贴同样的代码了,减少代码的体积:

    <!-- 伪组件 -->
    <!-- Card.comp -->
    <div class="card">
      <div class="card__title"></div>
      <div class="card_content"></div>
    </div>
    
    <!-- playlist.html -->
    <Card />
    
    <!-- homepage.html -->
    <Card />
    
    <!-- user.html -->
    <Card />
    

    当某个页面内容是复合组件时,那么可以直接把基础组件直接拿过来应用:

    <Card>
      <Title></Title>
      <Button></Button>
    </Card>
    

    利用这种方式,甚至可以达到 1 分钟产生一个新页面的恐怖速度,这对于你来说,节省时间去摸鱼,岂不美哉?

    <Page title="页面1" data="{...}" /> <Page title="页面2" data="{...}" />
    

    对于大型的公司来说,公司的网站、APP、桌面应用、Web 端应用等的设计风格都是一样的,同样的组件会在不同平台中使用,这个时候团队之间可以共享一套组件库,复用到各端平台上,减少重复开发的成本。React 和 Vue 都支持创建跨平台的应用,这时组件化开发就显得更重要了:

    在这里插入图片描述

    使用组件化开发之后,代码也容易维护了,如果页面某个部分出了问题,那么我们可以针对出现问题的组件进行修复,多次用到这个组件的地方也都会一起修复了。
    最后,设计师在设计产品界面的时候,会把重复出现的 UI 也做成『组件』,这个组件的概念几乎和前端中的组件一模一样,这时可以跟设计师交流想法,看看他/她是怎么规划组件的,这样也减少了在开发时,设计规划组件的时间。

    接下来分享一下我在组件化开发中总结的经验:

    一、组件的规划

    在正式进行前端应用开发之前,需要有充分的时间来分析,看看页面上的哪些内容需要做成组件。这一步只需要大致规划一下:

    • 如果公司设计师提供了详细的设计规范,那么直接按照规范中的组件来开发就可以了。

    在这里插入图片描述

    • 如果只有设计稿,那么就看看哪些内容有 2 次或更多次在其它页面中用到了,这些大概率需要设计为组件。
    • 如果连设计稿都没有,那么可以用市面上现成的组件库,例如 ant design。
    • 如果没有设计稿,还要自己从零开发,那么可以根据通用的套路,把基础组件,例如按钮、菜单等,规划出来,并把可能会多次用到的页面内容,也规划出来,例如导航,底部信息、联系方式区域,这样可以只改动需要变化的部分,不影响其它部分。

    这一步不用太过详细,浪费太多时间,后续开发的时候如果遇到不确定是否要写成组件的部分,可以直接把这部分代码写到大的组件里,如果其它组件又用到了,再把它抽离成组件。

    二、组件代码管理

    组件的代码应该遵循就近原则,也就是说:

    • 和组件有关的 HTML、CSS 、JS 代码和图片等静态资源应该放在同一个目录下,方便引用。
    • 组件里的代码应该只包括跟本组件相关的 HTML 模板、CSS 样式和 JS 数据逻辑。
    • 所有的组件应放到一个统一的『组件文件夹中』。

    如果组件之间有可以复用的 HTML 和 CSS,那么这个复用的部分可以直接定义成一个新的组件。

    如果组件之间有可以复用的 JS 数据逻辑,那么可以把公用的数据逻辑抽离出来,放到公共的业务逻辑目录下,使用到该逻辑的组件,统一从这个目录中导入。

    如果项目中使用到了全局状态管理,那么状态管理的数据应放在独立的目录里,这个目录还会存放分割好的状态片段 reducer,之后统一在 store 中合并。

    对于项目中的** API 处理**,可以把它们单独放到一个文件夹里,对于同一个数据类型的操作,可以放到同一个 js 文件里,例如对 user 用户数据的增删改查,这样能尽最大可能进行复用,之后在组件里可以直接引入相关 api 进行调用。如果直接写在组件里,那么使用相同 API 的组件就会造成代码重复。
    例如下面是一个组件化开发的目录结构示例(框架无关):

    project
    |-- components                # 所有组件
          |-- Card                # Card 组件
              |-- index.js        # Card 组件 js 代码
              |-- Card.html       # Card 组件 html 模板
              |-- Card.css        # Card 组件 css 样式
              |-- icon.svg        # Card 组件用到的 icon
    |-- logics                    # 公共业务逻辑
          |-- getUserInfo.js      # 例如获取用户信息
    |-- data                      # 全局状态
          |-- store.js            # 全局状态管理 store
          |-- user.reducer.js     # user reducer
          |-- blogPost.reducer.js # blogPost reducer
    |-- apis                      # 远程请求 API 业务逻辑
          |-- user.js             # user API
          |-- blogPost.js         # blogPost API
    

    三、组件样式管理

    在编写组件样式的时候,应只设置组件 CSS 盒子内部的样式,影响外部布局的样式要尽可能的避免,而应该由使用该组件的父组件去设置。例如,如果有一个组件设置了外边距,但是这个组件经常会用于 grid 或 flex 布局中,那么这个额外的边距会对布局造成影响,只能通过重置外边距的方式取消边距,这就不如组件不设置外边距,由父组件的布局决定它的位置,或者外边距。

    在这里插入图片描述

    类似的还有定位相关的样式,绝对定位、固定定位等对文档流有影响,应交由父组件决定,除非这个组件只有绝对定位这一种情况,例如对话框。
    组件中的 CSS 要局部化,以避免影响全局样式。传统的 CSS 样式是全局的,如果有两个不同的组件,使用了相同的 class 名字,那么后定义的样式会覆盖之前定义的。一般前端库中都有定义局部样式的功能,例如通过 CSS Modules。

    <!-- Vue -->
    <style scoped></style>
    
    <!-- React,通过文件名 -->
    Button.module.css
    

    修改子组件的样式时,优先使用选择器特异性(CSS Specificity)策略选定特定元素,而行内样式(inline-style)在设置简单样式的时候使用,尽一切可能避免 !important,因为如果再有上一层组件(爷爷组件)需要修改这个组件的样式时,就会很困难了。

    四、组件属性管理

    组件属性的命名要与它实际展示的内容相符。例如一个博客文章组件,title 属性表示标题,content 代表内容,showFullArticle 表示是否显示全文。

    <!-- 不推荐,full 表示什么? -->
    <BlogPost title="" content="" full="" />
    <!-- 推荐 -->
    <BlogPost title="" content="" showFullArticle="" />
    

    组件的属性应有必要的类型检查,避免在使用属性时出现异常,例如在需要数组的地方传递了布尔类型,那么如果代码有遍历数组的逻辑,就会出错。

    props: {
    	title: String,
      content: String,
      showFullArticle: Boolean
    }
    

    代表事件的属性,应该和现有的 HTML 事件名称规范保持一致,以 on 开头,后面用英文表示会触发的事件,例如 onEdit 表示会触发编辑事件。

    <BlogPost onEdit="" />
    

    组件的属性不能直接和状态进行捆绑,而是应该只作为状态的初始值。如果把属性值作为状态值,那么就破坏了单一数据流向机制,此时该组件可以通过自身修改状态,也能通过父组件的属性变化修改状态,很容易造成数据的不一致。推荐的做法是,设置一个初始值属性,可以通过父组件传递进来,当作状态的初始值,然后丢弃,后续只通过该组件修改状态值。

    const { initialTitle } = props;
    const title = state(initialTitle);
    
    // 修改
    updateTitle() {
     title = "...";
    }
    

    五、组件状态管理

    组件的状态分为全局状态和局部状态两种。
    局部状态是定义在组件本身的状态,应由组件本身内部管理,当子组件需要该组件的状态值时,通过属性传递给子组件,此时状态变化时,子组件也会自动刷新。

    // 父组件
    const someState = state("");
    
    <ChildComponent prop1="someState"></ChildComponent>;
    

    当子组件需要给父组件传递状态的值时,要通过事件的方式传递给父组件,尽最大可能避免使用 ref

    // 父组件
    function getStateVal(val) {
      console.log(val);
    }
    <ChildComponent onChange="getStateVal" />
    
    // 子组件
    <input onChange="e => getStateVal(e.target.value)" />
    

    状态的变化还应只通过事件或生命周期来进行,不能在其它同步执行的代码中进行,这样不会引起组件的刷新。

    const someState = state();
    
    // 错误
    const state = "newState";
    
    // 正确
    handleButtonClick() {
      someState = "newState";
    }
    

    全局状态是多个组件共享的,如果有多个组件共享某个状态,那么应该把状态定义在这些组件统一的、最接近的父组件中,或者使用全局状态管理库。

    在这里插入图片描述

    全局状态的修改,应该由类似于 actions 的行为触发,然后使用 reducer 修改状态,这样能追溯状态的变化路径,方便调试和打印日志。

    // 组件
    function updateState() {
      emitAction("changeState");
    }
    
    // reducer
    function someState(state, action) {
    	switch(action) {
        "changeState": someState => {
          	log(someState);
        		return newState
        }
      }
    }
    

    全局状态推荐按领域(Domain)来拆分 reducer,而不是按页面。例如按 user 用户、文章 posts、评论 comments 来拆分,而不是以 HomePage 主页、BlogPostListPage 博客列表页,BlogPostPage 博客详情页这样来拆分。这样做的好处是,能够最大限度的复用 reducer 中的逻辑。

    // userReducer
    
    {
    	"updateUser": ...
      "deleteUser": ...
      /* ... */
    }
    

    六、组件的组合

    前端开发就是组合不同的组件。
    在组合组件的时候,尽量使用『插槽』的形式(例如 React 的 children/render props,Vue 的 slot),这样可以减少组件的嵌套,避免多层传递属性或事件监听。
    使用 slot:

    // Layout 组件
    <div>
      <!-- nav slot -->
      <!-- content slot -->
      <!-- footer slot -->
    </div>
    
    // 首页 function handleNavChange() {}
    
    <Layout>
      <nav onChange="handleNavChange"></nav>
      <main></main>
      <footer></footer>
    </Layout>
    

    不使用 slot:

    // Layout props: { onNavChange: function }
    <Layout>
      <!-- 还需再传递一层 -->
      <nav onChange="onNavChange"></nav>
      <main></main>
      <footer></footer>
    </Layout>
    
    // 首页 function handleNavChange() {}
    <Layout onNavChange="handleNavChange" />
    

    如果有循环展示列表的地方,需要对循环中最外层的组件设置 key,这样在列表发生变化时,能帮助前端库判断是否可以通过排序的方式,重复利用现有的组件,来更新视图,而不是销毁重建。

    let todos = [{id: 1, content: "todo1"}, {id:2, content: "todo2"}, {id:3,
    content: "todo3"}];
    
    <List>
      for todo in todos:
      <item content="todo.content" key="todo.id" />
    </List>
    
    // todos 顺序变化,列表也只是根据 id 调整顺序,不会销毁重建 todos = [{id: 3,
    content: "todo3"}, {id:2, content: "todo2"}, {id:1, content: "todo1"}];
    

    如果有按条件展示组件的地方,且切换频率高,或有动画需求,要使用设置 css display 的方式,例如 vue 中的 v-show,如果切换频率低,可以使用加载、销毁的方式,例如 vue 中的 v-if,React 中使用 && 逻辑判断。

    七、组件的复用

    在复用组件的时候,可以通过改变组件的属性来修改一些简单的组件内容。

    <Card title="" content="<ContentComp />" />
    

    如果组件结构类似,但是有些内部的组件不一样,可以考虑通过『插槽』来复用。

    <!-- Comp -->
    <div>
      <h1></h1>
      <!-- slot -->
    </div>
    
    <!-- 其它组件 -->
    <Comp>
      <p>替换 slot</p>
    </Comp>
    

    如果有业务逻辑需要复用,尤其是涉及到状态变化的,那么可以把它抽离为公共的业务逻辑,利用 Hooks(React)或 Composables (Vue)来复用。

    // 公共逻辑 (/logic/useSomeLogic.js)
    function useSomeLogic() {
      const someState = state();
      const updateState = (v) => (someState = v);
      return {
        someState,
        updateState,
      };
    }
    
    // 组件1复用
    import userSomeLoginc from "/logic/useSomeLogic.js";
    const { someState, updateState } = useSomeLogic();
    
    // 组件2复用
    import userSomeLoginc from "/logic/useSomeLogic.js";
    const { someState, updateState } = useSomeLogic();
    

    如果有视图样式需要复用,那么可以直接把这部分再抽离成一个新的组件。

    小结

    这篇文章从组件的代码、样式、属性、状态、组合和复用的这几个场景上,总结了一些我在前端开发中的一些经验和个人看法,可能并不适用所有项目,如果你有更好的最佳实践和经验,欢迎分享!如果觉得本文有帮助,请分享给其它人,感谢!

    原文地址:https://zxuqian.cn/7-ways-to-organize-frontend-components,欢迎访问查看更多前端开发教程!
    Bilibili:峰华前端工程师
    公众号:峰华前端工程师

    展开全文
  • 应用“因子分析”模型,选取反映各区域综合经济实力的11个指标作为原始变量,对重庆市4 0个区市县的综合经济发展水平做分析评价,以选出重庆市区域经济增长极进行优先开发
  • 文章目录邻接矩阵存储图的广度优先遍历过程分析C语言实现队列编程程序中加入图的处理函数结果的再次分析C#语言实现图的广度优先遍历、并显示广度优先遍历生成树JavaScript语言实现图的广度优先遍历、并显示广度优先...


    邻接矩阵存储图的广度优先遍历过程分析

    对图1这样的无向图,要写成邻接矩阵,则就是下面的式子
    在这里插入图片描述在这里插入图片描述一般要计算这样的问题,画成表格来处理是相当方便的事情,实际中计算机处理问题,也根本不知道所谓矩阵是什么,所以画成表格很容易帮助我们完成后面的编程任务。在我们前面介绍的内容中,有不少是借助着表格完成计算任务的,如Huffman树。

    在这里插入图片描述
    为了记录那些顶点是已经走过的,还要设计一个表来标记已经走过的顶点,在开始,我们假设未走过的是0,走过的是1,于是有:

    在这里插入图片描述
    对广度优先遍历,还需要补充一个队列、来记录一个顶点可以抵达到的其他顶点。

    广度优先遍历过程如下:

    在这里插入图片描述
    结果分析

    从上面的过程可以看出:仅仅就顶点访问到的次序而言,图1的广度优先遍历结果是:

    V1->V2->V3>V4->V5->V6->7->V8
    

    但实际执行过程中我们可以发现:所谓图的广度优先遍历、其结果应该是一个树:

    在这里插入图片描述
    在C语言中,显示这个结果并不容易,所以大多C语言的教材中并不会给出这样的结果。

    C语言实现队列编程

    根据上面的分析,我们可以知道:要广度优先遍历图,首先要一个队列系统。

    队列在C语言上只能自己构造,好在我们前面有链表、有顺序表,我们可以复制过来一个链表程序构造一个队列,于是从链表程序中复制过来b5.c或者b6.c即可,我们分析队列的ADT可知,最需要的队列功能需求是:

    QueueInit()、EnQueue、DeQueue()、QueueEmpty()这4个函数,于是有以下队列定义:

    struct Queue 
    {
    	struct LinkedList * LinkQueue;
    	int Count;
    };
    
    

    由于我们已经确定使用链表做队列,所以队列实际就是链表的换名包装,所以我们可以理解为队列就是链表的另一种应用,表3的程序就是这样的做法,所以对队列的初始化,就是:

    struct Queue * QueueInit()
    {
    	struct Queue *q;
    	q=(struct Queue *)malloc(sizeof(struct Queue));
    	q->LinkQueue=LinkedListInit(); 
    	q->Count=0; 
    	return q;
    }
    
    

    有了队列的初始化,则进入队列、实际相当于给这个链表追加一条记录,就是Append()的另类包装:

    int EnQueue(struct Queue *Q,struct ElemType *E)
    {
    	if(Q==NULL) return -1;
    	if(E==NULL) return -2;
    	Append(Q->LinkQueue,E);
    	Q->Count++; 
    	return 0;
    }
    

    注意数据出队列,出队列总是把链表中第一个结点的数据给出来、并删除第一个结点,所以出队列就是:

    int DeQueue(struct Queue *Q,struct ElemType *E)
    {
    	struct ElemType *pE;
    	if(Q==NULL) return -1;
    	if(E==NULL) return -2;
    	pE=LinkedListGet(Q->LinkQueue,1);
    	ElemCopy(pE,E); 
    	LinkedListDel(Q->LinkQueue,1); 
    	Q->Count--;
    	return 0;
    }
    
    

    出队列函数总是把第一个结点删除掉,注意队列完全可能数据出完后再次有数据进入队列,则原来的结点删除函数有Bug,这在程序开发中很正常,修改后就是:

    int LinkedListDel(struct LinkedList *L,int n)
    {
    	int i;
    	struct Node *p0,*p1;
    	if(L==NULL) return -1;
    	if(n<0||n>L->Count) return -2;
    	p0=L->Head;
    	for(i=0;i<n-1;i++) 
    		p0=p0->next;
    	p1=p0->next;
    	p0->next=p1->next;
    	free(p1);
    	L->Count--;
    	if(L->Count==0) L->Tail=L->Head;  
    	return 0;
    }
    
    

    修改的这个链表结点函数、仅仅加了第14行,在过去,所以结点删除后,最后的尾巴结点指针Tail所指的存储空间被释放,导致这个指针变量不可用,现在在结点个数为0的情况下,再次让尾结点指向头结点,保证下次进入链表的数据依然正确。

    而判断队列是否为空则相对简单的多,就是:

    int QueueEmpty(struct Queue *Q)
    {
    	if(Q==NULL) return -1;
    	return !(Q->Count); 
    }
    

    补充main()函数,测试多批次进入队列、出队列,全部程序见B0.c

    在我们的图遍历应用中,我们对队列的数据仅仅要求一个整数即可,而这个程序进出队列的数据有三列数据,为加强该程序可靠行,修改ElemType(),就是:

    void ElemCopy(struct ElemType *s,struct ElemType *d)
    {
    	d->sNo=s->sNo;
    	//strcpy(d->sName,s->sName);
    	//d->sAge=s->sAge;  
    }
    
    

    在一个系统中,类似这样的修改很正常,使用已有的程序完成自己的工作,会大大加快编程的进度,使得编程工作更加流畅。
    而这一切都需要自己有足够的积累,有这个积累后完成这样的工作才有基础,所谓技术水平,就是不断积累的过程。

    下面,在图的处理中会再次体现这样的过程。

    程序中加入图的处理函数

    我们的队列系统完成后,记着再复制一个文件,加入图的邻接矩阵读数据程序,我们这里这个程序名称是b1.c。对邻接矩阵数据的读取、并构造图的过程,在深度优先遍历程序中已完成,所以直接复制过来即可,回顾广度优先遍历算法,就是把第一个顶点先无条件装进队列,所以编写遍历BFSM函数如下:

    四、程序中加入图的处理函数
    我们的队列系统完成后,记着再复制一个文件,加入图的邻接矩阵读数据程序,我们这里这个程序名称是b1.c。对邻接矩阵数据的读取、并构造图的过程,在深度优先遍历程序中已完成,所以直接复制过来即可,回顾广度优先遍历算法,就是把第一个顶点先无条件装进队列,所以编写遍历BFSM函数如下:
    void BFSM(struct Graph *G)
    {
    	int i,n;
    	struct Queue *Q;
    	struct ElemType *p,E,e;
    	Q=QueueInit();	
    	E.sNo=0;           // 设置0进队列
    	EnQueue(Q,&E);
    	G->Visited[0]=1;     // 设置0号顶点已被访问
    	p=&e;
    	while(!QueueEmpty(Q))
    	{
        //待补充
    	}
    }
    
    

    从第11行开始,则进入真正的遍历。

    有这么个函数后,我们可以补充main()的测试函数就是:

    main()
    {
    	struct Graph *G;
    	G=GraphCreat("p176G719.txt");
    	BFSM(G);
    }
    
    

    main()很短,也很简单,如有不明白的回顾下深度优先遍历函数。

    回顾一下:就是队列Q里出队列,然后找与该顶点相连的所有顶点、在进队列,就是:

    void BFSM(struct Graph *G)
    {
    	int i,n;
    	struct Queue *Q;
    	struct ElemType *p,E,e;
    	Q=QueueInit();	
    	E.sNo=0;
    	EnQueue(Q,&E);
    	G->Visited[0]=1; 
    	p=&e;
    	while(!QueueEmpty(Q))
    	{
    		DeQueue(Q,p);
    		n=p->sNo;
    		printf("%s\n",G->pV[n]);
    		for(i=0;i<G->num;i++)
    			if(G->pA[n][i]==1&&G->Visited[i]==0)
    			{
    				G->Visited[i]=1; 
    				E.sNo=i;
    				EnQueue(Q,&E);
    			}
    	}
    }
    
    

    运行这个程序、就会打印出这个图的广度优先遍历结果。

    结果的再次分析

    有了这个函数后,构造main()开始从第0个顶点遍历图1,就是:

    进一步测试该函数,按图1的数据仔细分析下它的执行过程,如有图的连接分量不为1,则会在第一个连接分量遍历完成后终止。如下图4,在B1.C中是无法全部遍历完成的。这个图的文件在G4.TXT,修改表23中第5行,从G4.TXT中读数据,则会发现这个程序仅仅遍历了A、B、C、D,而没有到达过E、F、G这三个顶点。

    在这里插入图片描述
    这个图该如何遍历呢?请同学们自己修改程序,完成这个图的遍历。
    广度优先遍历到此结束。

    C#语言实现图的广度优先遍历、并显示广度优先遍历生成树

    在C#文件夹中可以找到“Graph0.cs”,这个文件中包含着深度优先遍历、广度优先遍历等程序中的所有图类程序,现在,我们就要在这个类中补充新的方法。
    首先复制这个类到Graph.cs,然后用C#建立一个Windows应用程序,然后在资源管理器中添加这个类,这个类和在深度优先遍历中的类完全一致,但去掉了命名空间说明,这样,这个类就可以使用在其他工程中了。

    首先是再次熟悉这个类中的变量定义:

    private int[,] A         //邻接矩阵
    private string[] V       //顶点矩阵
    private int[] Visited    //顶点访问表
    private TreeNode[] T     //遍历生成树
    private int num          //顶点个数
    private int ConnComp     //连通分量
    

    找到这个类中的最后一个方法:DSFTraverse(),然后开始在这个方法后补充新方法:DFS(),由于算法和C语言完全一致,此处算法问题不在介绍。

    private void BFS(int N)
    {
                int n;
                Queue<int> Q = new Queue<int>();
                Q.Enqueue(N);
                Visited[N] = 1; 
                while (Q.Count != 0)
                {
                    n = Q.Dequeue();
                    for (int i = 0; i < num; i++)
                        if (A[n, i] == 1 && Visited[i] == 0)
                        {
                            T[n].Nodes.Add(T[i]);  
                            Visited[i] = 1; 
                            Q.Enqueue(i);
                        }
                }
    }
    
    

    这个方法可以从第N个顶点开始遍历,同前面涉及的问题一样,考虑到多次遍历、以及多连通分量的图,我们还要补充下面的方法:

            public int BFSTraverse()
            {
                int i;
                ConnComp = 0;
                for (i = 0; i < num; i++)
                {
                    T[i] = new TreeNode(V[i]);
                    Visited[i] = 0;
                }
                for (i = 0; i < num; i++)
                    if (Visited[i] == 0)
                    {
                        BFS(i);
                        ConnComp++;
                    }
                return ConnComp; 
            }
    
    

    补充完类Graph中两个方法补充后、就可以进行界面设计,设计界面如下:

    在这里插入图片描述
    根据图1的界面设计,则广度优先遍历程序中连通分量为1的图在button1下,于是有:

    private void button1_Click(object sender, EventArgs e)
    {
                int m;
                int[,] A = {
                                {0, 1, 1, 0, 0, 0, 0, 0},
                                {1, 0, 0, 1, 1, 0, 0, 0},
                                {1, 0, 0, 0, 0, 1, 1, 0},
                                {0, 1, 0, 0, 0, 0, 0, 1},
                                {0, 1, 0, 0, 0, 0, 0, 1},
                                {0, 0, 1, 0, 0, 0, 1, 0},
                                {0, 0, 1, 0, 0, 1, 0, 0},
                                {0, 0, 0, 1, 1, 0, 0, 0}
                             };
                string[] V = { "V1", "V2", "V3", "V4", "V5", "V6", "V7", "V8" };
                Graph G = new Graph(8);
                G.Arc = A; G.Vertex = V;
                m = G.BFSTraverse(); 
                treeView1.Nodes.Clear();
                treeView1.Nodes.Add(G.DFSResult);
                textBox1.Text = "该图连接分量为" + m.ToString(); 
    }
    
    

    由于类设计中、广泛使用了原有的代码,所以这段程序看起来和深度优先遍历的测试代码差别很小。同理,在有多个连通分量的情况下,在button2下的代码是:

            private void button2_Click(object sender, EventArgs e)
            {
                int m;
                int[,] A = {
                            {0, 1, 1, 0, 0, 0, 0},
                            {1, 0, 0, 1, 0, 0, 0},
                            {1, 0, 0, 1, 0, 0, 0},
                            {0, 1, 1, 0, 0, 0, 0},
                            {0, 0, 0, 0, 0, 1, 1},
                            {0, 0, 0, 0, 1, 0, 1},
                            {0, 0, 0, 0, 1, 1, 0}
                           };
                string[] V = { "A", "B", "C", "D", "E", "F", "G" };
                Graph G = new Graph(7);
                G.Arc = A; G.Vertex = V;
                m = G.BFSTraverse(); 
                treeView1.Nodes.Clear();
                G.AddInTreeView(treeView1);
                textBox1.Text = "该图连接分量为" + m.ToString(); 
            }
    
    

    请自行补充button3下的代码。

    程序运行结果就是:
    在这里插入图片描述图的广度优先遍历到此结束。通过上述编程我们可以发现:大量使用已有的代码,可以大大简化编程的复杂程度。

    问题:

    我们在C#的程序中、并没有使用类似C语言那样的技术:在数据文件中保存图的数据,这首先是基于我们对C#的使用方式造成的,C#最重要的应用场合是连接数据库服务器和前端的用户浏览器,这个场合下C#提供一个正确的运算类就足够了,其数据要来自于数据库,而结果要给到浏览器上的程序。浏览器下的程序就是JavaScript,这样的情况下C#不做数据文件读取、而要做的是数据库上数据读取,至于送到JavaScript,这个对C#、就要通过一种叫WebService的技术,而在JavaScript上、则要用到一种叫Ajax技术读写这些数据,而这些都是下学期的重要实验任务。

    JavaScript语言实现图的广度优先遍历、并显示广度优先遍历生成树

    对JavaScript而言,是没有队列类的,尽管数组的类型直接泛型,但仅有栈而无队列。我们需要最低代价完成一个队列系统,所以要再次查看JavaScript数组的所有方法和属性:

    其中:FF: Firefox, IE: Internet Explorer

    在这里插入图片描述
    而这个对象提供的属性,则如下表:FF: Firefox, IE: Internet Explorer

    在这里插入图片描述
    回顾栈和队列的差异,一个是先进后出、一个是先进先出,查找上述数组的方法,有个方法是reverse(),含义是颠倒数组元素的次序,很显然:

    如果进队列是数组的push()操作,那么出队列则就是颠倒数组次序、然后pop()操作,有这个思路,按这个算法构造队列类就是:

    		function Queue()
    		{
    		this.Q=new Array();
    		this.EnQueue=function(E)
    			{
    			this.Q.push(E);
    			}
    		this.DeQueue=function()
    			{
    			var E;
    			this.Q=this.Q.reverse();
    			E=this.Q.pop();
    			this.Q=this.Q.reverse();
    			return E;
    			}
    		this.Count=function()
    			{
    			return this.Q.length;
    			}
    		}
    
    

    一定注意这个类的第13行,颠倒次序出栈后一定要再次颠倒这个数组的次序,保证进栈数据的次序。这样,我们就用最小代价完成了一个队列系统,然后补充多次进出队列的测试网页,就是:

    <html>
    	<head>
    	<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
    	<title>一个调用Ext类库的模板页面</title>
    		<script type="text/javascript" src="Queue.js"></script>
    		<script type="text/javascript" src="ext-3.0.0/adapter/ext/ext-base.js"></script>
      		<script type="text/javascript" src="ext-3.0.0/ext-all.js"></script>
       		<link rel="stylesheet" type="text/css" href="ext-3.0.0/resources/css/ext-all.css" />  
    	</head>
    	<body bgcolor="#FFFFFF">
    	<div id="hello"></div>
    	<script type="text/javascript">
    		function fun()
    		{
    		var Q=new Queue();
    		Q.EnQueue(1);
    		Q.EnQueue(2);
    		Q.EnQueue(3);
    		while(Q.Count()>0)
    			{
    			document.write(Q.DeQueue()+'<br>');
    			}
    		Q.EnQueue(4);
    		Q.EnQueue(5);
    		while(Q.Count()>0)
    			{
    			document.write(Q.DeQueue()+'<br>');
    			}
    	     }
     	Ext.onReady(fun);
    	</script>
    	</body>
    </html>
    
    

    注意第5行一定要引用Queue.js这个文件,否则程序无法运行。

    补充广度优先遍历程序

    根据广度优先遍历的算法、以及表1的队列对象,不难写出广度优先遍历程序,但写以前我们要回顾深度优先遍历函数的入口参数:

    A[][]: 邻接矩阵
    vCount: 顶点个数
    m: 进入遍历的顶点编号
    Visited[] :顶点访问状态表
    T[]: Ext.tree.TreeNode对象数组,遍历结果树

    我们回顾这些的原因是:我们新的遍历函数、也要尽量和旧的方法使用的参数一致,这样就对后续的编程提供了大量的方便。如果意义相近的方法、其函数入口参数差异很大、这样对后续的编程造成很多困惑。

    //A[][]:     邻接矩阵
    //vCount:    顶点个数
    //m:         进入遍历的顶点编号
    //Visited[] :顶点访问状态表
    //T[]:       Ext.tree.TreeNode对象数组,遍历结果树
    function BFS(A,vCount,m,Visited,T)
    {
    		var i,n;
    		var Q=new Queue();
    		Q.EnQueue(m);
    		Visited[m]=1;
    		while(Q.Count()>0)
    			{
                    n = Q.DeQueue();
            	        for (i = 0; i <vCount; i++)
                    	    if (A[n][i] == 1 && Visited[i] == 0)
    	                    {
            	                T[n].appendChild(T[i]);
    	                        Visited[i] = 1; 
    	                        Q.EnQueue(i);
    	                    }			
    			}
    }
    
    

    表3 JavaScript语言图的广度优先遍历,见工程B0.html

    该函数算法不在介绍,程序原理和C、C#没什么差别。

    从深度优先遍历网页补充广度优先遍历程序

    从深度优先遍历网页G8.html复制文件到B0.html,在F3区域的邻接矩阵编辑窗口补充命令按钮“广度优先遍历”,就是表4.
    对这个表中的程序,注意是一个程序框架,而不是全部。现在就要在合适的位置补充广度优先遍历的初始化程序。

    var grid=new Ext.grid.EditorGridPanel({
    			renderTo:"GRID",
    			title:"图的邻接矩阵编辑",
    			height:400,
    			width:400,
    			cm:colM,
    			store:gstore,
    			tbar: [ 
    			{ 
    			text: "深度优先遍历图",   
    			handler: function()
    					{ 
    					//已有的深度遍历代码
    					} 
    			},
    			{
    			text:"广度优先遍历图",
    			handler: function()
    					{
    			          //以下写进遍历的代码
    					} 
    			}
    			] 
    });
    
    

    注意表4,其第20行就是补充广度优先遍历程序的地方,这程序本质就是给BFS()准备合适的数据、并初始化、然后调用BFS()函数,所以这地方和深度优先遍历的代码是一致的,于是有:

    text:"广度优先遍历图",
    handler: function()
    {
    //以下写进遍历的代码
    		var m=gstore.getCount();
    		var n=gstore.getAt(m-1).get('row')+1;
    		var Visited=Array();
    		var A=Array();
    		var i,j;
    		for(i=0;i<n;i++)
    			{
    			Visited[i]=0;
    			A[i]=Array();
    			T[i]=new Ext.tree.TreeNode({id:vstore.getAt(i).get('id'),text:vstore.getAt(i).get('V')});
    			}
    		for(i=0;i<m;i++)
    			{
    			var r=gstore.getAt(i).get('row');
    			var c=gstore.getAt(i).get('col');
    			var v=gstore.getAt(i).get('Value');
    			A[r][c]=v;
    			}
    			var Concom=0;
    		for(i=0;i<n;i++)
    			if(Visited[i]==0) 
    				{
    				BFS(A,n,i,Visited,T);Concom++;
    				}
    				var TR=new Ext.tree.TreeNode({id:10000,text:'广度优先遍历树,连通分量'+Concom});
    		for(i=0;i<n;i++)
    				if(T[i].parentNode==null)
    							TR.appendChild(T[i]);
    		treeView1.setRootNode(TR);
    } 
    }
    
    

    和前面深度优先遍历的程序完全一致,仅仅是调用了不同的遍历函数。

    遍历网页的进一步修改和完善:构造图类

    从B0.html这个网页程序看,首先在两个遍历的命令按钮程序上有大量重复代码,其次是有关图的计算,其邻接矩阵、顶点矩阵、顶点访问状态矩阵、遍历函数等都是分离的变量和函数,而没有构成一个类、从而也就没有图的对象,这样对后续的编程也造成很多不利。

    为此,我们要构造一个JavaScript的图类,整体参照C#。

    对任何一个语言的类编程而言,都存在数据如何进入对象、以及数据如何从对象里给出这两个基本问题,在使用Ext过程中,我们熟悉了大量的Ext对象属性获得方法,那么我们这里也将按同样的方法来构造类,详细的介绍参见json教程。以下类名称是Graph,其中G是属性参数:

    function Graph(G)
    {
    this.A=G.A;
    this.V=G.V;
    this.Visited=G.Visited;
    this.num=G.num;
    this.T=G.T;
    }
    
    
    <html>
    	<head>
    	<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
    	<title>一个调用Ext类库的模板页面</title>
    		<script type="text/javascript" src="G0.js"></script>
    		<script type="text/javascript" src="ext-3.0.0/adapter/ext/ext-base.js"></script>
      		<script type="text/javascript" src="ext-3.0.0/ext-all.js"></script>
       		<link rel="stylesheet" type="text/css" href="ext-3.0.0/resources/css/ext-all.css" />  
    	</head>
    	<body bgcolor="#FFFFFF">
    	<div id="hello"></div>
    	<script type="text/javascript">
    		function fun()
    		{
    		var G=new Graph({
    			      A:[[1,2,3],[4,5,6],[7,8,9]],V:['A','B','C'],Visited:[0,0,0]
    			      });
    	     }
     	     Ext.onReady(fun);
    	</script>
    	</body>
    </html>
    
    

    注意第16行,其中构造函数的参数里:

    {A:[[1,2,3],[4,5,6],[7,8,9]],V:['A','B','C'],Visited:[0,0,0]}
    

    整体构成对象G,进入类后,进入表5程序后,由第3到第5行的程序赋值给对象相应的属性。再次参照表5程序,其中的this,对应在表6的程序是G,广义上,实例化的对象就是表5中的this。

    有了上述分析,我们就可以在表5的程序中加入一个公共方法,用来获得属性中V数组的内容,代码就是:

    function Graph(G)
    {
    this.A=G.A;
    this.V=G.V;
    this.Visited=G.Visited;
    this.num=G.num;
    this.T=G.T;
    this.VName=function()
    	{
    	var i;
    	for(i=0;i<this.num;i++)
    		document.write(this.V[i]);
    	}
    }
    
    

    这样写的方法类似是C#中的public void VName(),这样的写法可以在实例对象中引用这样方法,如:

    <html>
    	<head>
    	<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
    	<title>一个调用Ext类库的模板页面</title>
    		<script type="text/javascript" src="G1.js"></script>
    		<script type="text/javascript" src="ext-3.0.0/adapter/ext/ext-base.js"></script>
      		<script type="text/javascript" src="ext-3.0.0/ext-all.js"></script>
       		<link rel="stylesheet" type="text/css" href="ext-3.0.0/resources/css/ext-all.css" />  
    	</head>
    	<body bgcolor="#FFFFFF">
    	<script type="text/javascript">
    	function fun()
    	{
    	 var G=new Graph({
    			      A:[[1,2,3],[4,5,6],[7,8,9]],
    			      V:['A','B','C'],
    			Visited:[0,0,0],
    			    num:3
    			});
    		G.VName();
    	}
     	Ext.onReady(fun);
    	</script>
    	</body>
    </html>
    
    

    上述过程完成后,可以加入一个求V数组中每行平均值的方法,涉及到求平均值,首先我们需要一个求指定行和的函数,这个函数定义成私有的,如同表9的程序中的Sum(),私有函数定义和普通的JavaScript函数完全一致。

    但在实际使用中,错误首先在第17行,表示this.num是没有定义。

    造成这样的结果,主要是私有的函数Sum()并不包含在对象中,这点和C#是完全不一样,所以私有函数中要引用对象的数据,要首先获得该对象的实例,就是要有这样的方法:

    var Ob=this;
    function Sum()
    {for(i=0;i<Ob.num;i++)}
    
    
    function Graph(G)
    {
    this.A=G.A;
    this.V=G.V;
    this.Visited=G.Visited;
    this.num=G.num;
    this.T=G.T;
    this.VName=function()
    	{
    	var i;
    	for(i=0;i<this.num;i++)
    		document.write(this.V[i]);
    	}
    function Sum(n)
    {
    var s=0,i;
    for(i=0;i<this.num;i++)  //私有方法中错误引用对象数据
    	s+=this.A[n][i];
    return s;
    }
    this.AVG=function(n)
    	{
    	var s;
    	s=Sum(n)/this.num;	
    	}
    }
    
    
    function Graph(G)
    {
    this.A=G.A;
    this.V=G.V;
    this.Visited=G.Visited;
    this.num=G.num;
    this.T=G.T;
    this.VName=function()
    	{
    	var i;
    	for(i=0;i<this.num;i++)
    		document.write(this.V[i]);
    	}
    function Sum(n)
    {
    var s=0,i;
    for(i=0;i<this.num;i++)  //私有方法中错误引用对象数据
    	s+=this.A[n][i];
    return s;
    }
    this.AVG=function(n)
    	{
    	var s;
    	s=Sum(n)/this.num;	
    	}
    }
    
    
    function Graph(G)
    {
    this.A=G.A;
    this.V=G.V;
    this.Visited=G.Visited;
    this.num=G.num;
    this.T=G.T;
    var Ob=this;
    //公共方法
    this.VName=function()
    	{
    	var i;
    	for(i=0;i<this.num;i++)
    		document.write(this.V[i]);
    	}
    //私有方法
    function Sum(n)
    {
    var s,i;
    s=0;
    for(i=0;i<Ob.num;i++)
    	s+=Ob.A[n][i];
    return s;
    }
    //公共方法
    this.AVG=function(n)
    	{
    	var a;
    	a=Sum(n)/this.num;	
    	return a;
    	}
    }
    
    

    通过上述实验过程,则有两个遍历方法的图类就是:

    function Graph(G)
    {
    this.A=G.A;
    this.V=G.V;
    this.Visited=G.Visited;
    this.num=G.num;
    this.T=G.T;
    var Ob=this;
    //私有方法:深度优先遍历
    function DFS(m)
    {
    var i;
    Ob.Visited[m]=1;
    for(i=0;i<Ob.num;i++)
    	{
    	if(Ob.A[m][i]!=0&&Ob.Visited[i]!=1) 
    		{
    		Ob.T[m].appendChild(Ob.T[i]);
    		DFS(i);
    		}
    	}
    }
    //公共方法:深度优先遍历、以及初始化
    this.DSFTraverse=function()
    	{
    	var i,Comcon=0;
    	if (this.num==0||this.num==undefined) return -1;
    	for(i=0;i<this.num;i++)
    		{
    		this.Visited[i]=0;
    		this.T[i]=new Ext.tree.TreeNode({id:i,text:this.V[i]}); 
    		}
    	for(i=0;i<this.num;i++)
    		if(this.Visited[i]==0)
    			{
    			DFS(i);Comcon++;
    			}
    	return Comcon;
    	}
    //私有方法:广度优先遍历
    function BFS(m)
    {
    	var i,n;
    	var Q=new Queue();
    	Q.EnQueue(m);
    	Ob.Visited[m]=1;
    	while(Q.Count()>0)
    		{
    	        n = Q.DeQueue();
                    for (i = 0; i <Ob.num; i++)
                   	    if (Ob.A[n][i] == 1 && Ob.Visited[i] == 0)
    	            {
                            Ob.T[n].appendChild(Ob.T[i]);
    	                Ob.Visited[i] = 1; 
    	                Q.EnQueue(i);
    	            }			
    		}
    }
    //公共方法:深度优先遍历、以及初始化
    this.BSFTraverse=function()
    	{
    	var i,Comcon=0;
    	if (this.num==0||this.num==undefined) return -1;
    	for(i=0;i<this.num;i++)
    		{
    		this.Visited[i]=0;
    		this.T[i]=new Ext.tree.TreeNode({id:i,text:this.V[i]}); 
    		}
    	for(i=0;i<this.num;i++)
    		if(this.Visited[i]==0)
    			{
    			BFS(i);
    			Comcon++;
    			}
    	return Comcon;
    	}
    //获得遍历结果树,适应多个连接分量情况下。
    this.getTree=function()
    	{
    	for(i=1;i<this.num;i++)
    		if(this.T[i].parentNode==null)
    			this.T[0].appendChild(this.T[i]);
    	return this.T[0];
    	}
    }
    
    

    有了上述图类后,则相应的界面上“深度优先遍历”按钮下的相应程序就是:

    text: "深度优先遍历图",   
    handler: function()
    {   
    //以下写进遍历的代码
    	var m=gstore.getCount();
    	var n=gstore.getAt(m-1).get('row')+1;
    	var Visited=Array();
    	var A=Array();
    	var i,j;
    	for(i=0;i<n;i++)
    		{
    		Visited[i]=0;
    		A[i]=Array();
    		}
    	//获得邻接矩阵数据							
    	for(i=0;i<m;i++)
    		{
    		var r=gstore.getAt(i).get('row');
    		var c=gstore.getAt(i).get('col');
    		var v=gstore.getAt(i).get('Value');
    		A[r][c]=v;
    		}
    	//获得邻接矩阵数据							
    	var V=new Array();
    	//获得顶点名称
    	for(i=0;i<vstore.getCount();i++)
    		V[i]=vstore.getAt(i).get('V');
    	//用变量给对象各个属性赋值
    	var G=new Graph({
    				A:A,V:V,T:T,num:n,Visited:Visited
    		});				
    	m=G.DSFTraverse();
    	var TR=new Ext.tree.TreeNode({id:10000,text:'深度优先遍历树,连通分量'+m});
    	TR.appendChild(G.getTree());					
    	treeView1.setRootNode(TR);
    }   
    
    

    上面仅仅给出深度优先遍历的响应程序,广度优先遍历的代码同上述过程基本一样,仅仅是在第32行处为:m=G.BSFTraverse();

    到此,JavaScript的两种遍历全部完成,这里,图的数据来自Ext.data.ArrayStore对象,目前是常数定义或者控件输入,以后还要加入Ajax方法、从C#读远程数据库的数据,这都是下学期的任务了。

    在这里插入图片描述

    展开全文
  • 配置OSPF单区域

    千次阅读 2022-04-17 18:05:21
    它是IETF(Internet Engineering Task Force)组织开发的一个基于链路状态的自制系统内部路由协议(IGP),用于在单一自治系统(Autonomous System,AS)内决策路由。在IP网络上,它通过收集和传递自治系统的链路...

    目录

    一、相关知识

    1、OSPF协议简介

    2、OSPF优点

    3、OSPF链路状态协议有以下两个问题要注意:

    4、OSPF 支持的网络类型如下。

    5、NBMA 与P2MP之间的区别:

    6、OSPF的报文类型

    7、0SPF路由配置

    二、拓扑图

    三、配置命令

    1、ZY-Router-1路由配置命令

    2、ZY-Router-2路由配置命令

    四、验证过程


    一、相关知识

    1、OSPF协议简介

    OSPF是Open Shortest Path First(即“开放最短路由优先协议”)的缩写。它是IETF(Internet Engineering Task Force)组织开发的一个基于链路状态的自制系统内部路由协议(IGP),用于在单一自治系统(Autonomous System,AS)内决策路由。在IP网络上,它通过收集和传递自治系统的链路状态来动态地发现并传播路由。当前OSPF协议使用的是第二版,最新的RFC是2328。

    2、OSPF优点

    (1)适应范围:OSPF 支持各种规模的网络,最多可支持几百台路由器。

    (2)最佳路径:OSPF是基于带宽来选择路径的。

    (3)快速收敛:如果网络的拓扑结构发生变化,OSPF立即发送更新报文,使这一变化在自治系统中同步。

    (4)无自环:由于 OSPF 通过收集到的链路状态用最短路径树算法计算路由,因而从算法本身保证了不会生成自环路由。

    (5)子网掩码:由于OSPF在描述路由时携带网段的掩码信息,所以OSPF协议不受自然掩码的限制,为 VLSM 和 CIDR 提供很好的支持。

    (6)区域划分: OSPF 协议允许自治系统的网络被划分成区域来管理,区域间传送的路由信息被进一步抽象,从而减少了占用网络的带宽。

    (7)等值路由: OSPF 支持到同一目的地址的多条等值路由。

    (8)路由分级: OSPF 使用4类不同的路由,按优先顺序,分别是区域内路由、区域间路由、第一类外部路由、第二类外部路由。

    (9)支持验证:它支持基于接口的报文验证,以保证路由计算的安全性。

    (10)组播发送: OSPF 在有组播发送能力的链路层上以组播地址发送协议报文,既达到了广播的作用,又最大限度地减少了对其他网络设备的干扰。

    3、OSPF链路状态协议有以下两个问题要注意:

    (1)在初始发现过程中,链路﹣状态路由协议会在网络传输线路上进行洪泛( flood ),因此会大大削弱网络传输数据的能力。

    (2)链路﹣状态路由对存储器容量和处理器处理能力敏感。

    4、OSPF 支持的网络类型如下。

    (1)Point - to - Point :链路层协议是 PPP 或 LAPB 时,默认网络类型为点到点网络。无须选举 DR 和 BDR ,当只有两个路由器的接口要形成邻接关系时才使用。

    (2)Broadcast :链路层协议是 Ethemet 、 FDDI 、 Token Ring 时,默认网络类型为广播网,以组播的方式发送协议报文。

    (3)NBMA :链路层协议是帧中继、 ATM 、 HDLC 或 X .25时,默认网络类型为 NBMA 。手工指定邻居。

    (4)Point - to - Multipoint (P2MP):没有一种链路层协议会默认为是 Point - to - Multipoint 类型。点到多点必然是由其他网络类型强制更改的,常见的做法是将非全连通的 NBMA 改为点到多点的网络。多播 hello 包自动发现邻居,无须手工指定邻居。

    5、NBMA 与P2MP之间的区别:

    (1)在OSPF协议中, NBMA 是指那些全连通的、非广播、多点可达网络;而点到多点的网络则并不需要一定是全连通的。

    (2)NBMA 是一种缺省的网络类型。点到多点不是缺省的网络类型,点到多点是由其他网络类型强制更改的。

    (3)NBMA 用单播发送协议报文,需要手工配置邻居;点到多点是可选的,既可以用单播发送报文,也可以用多播发送报文。

    (4)在 NBMA 中需要选举 DR 与 BDR ,而在P2MP网络中没有 DR 与 BDR 。另外,广播网中也需要选举 DR 和 BDR 。

    6、OSPF的报文类型

    OSPF的报文类型一共有五种,分别是:

    (1)HELL0报文(Hello Packet ):最常用的一种报文,周期性地发送给本路由器的邻居。内容包括一些定时器的数值、 DR 、 BDR ,以及自己已知的邻居。 HELLO 报文中包含有 Router ID 、 Hello / deadintervals 、 Neighbors 、 Area - ID 、 Router priority 、 DR IPaddress 、 BDR IP address 、 Authenticationpassword 、 Stub area flag 等信息,其中 Hello / deadintervals 、 Area - ID 、 Authenticationpassword 、 Stub area flag 必须一致,相邻路由器才能建立邻居关系。

    (2)DBD 报文( Database Description Packet ):两台路由器进行数据库同步时,用 DBD 报文来描述自己的 LSDB ,内容包括 LSDB 中每一条 LSA 的摘要(摘要是指 LSA 的 HEAD ,通过该 HEAD 可以唯一标识一条 LSA )。这样做是为了减少路由器之间传递信息的量,因为 LSA 的 HEAD 只占一条 LSA 的整个数据量的一小部分,根据 HEAD ,对端路由器就可以判断出是否已经有了这条 LSA 。

    (3)LSR 报文( Link State Request Packet ):两台路由器互相交换 DBD 报文之后,知道对端的路由器有哪些 LSA 是本地 ISDB 所缺少的或是对端更新的,这时需要发送 LSR 报文向对方请求所需的 LSA 。内容包括所需要的LSA 的摘要。

    (4)LSU 报文( Link State Update Packet ):用来向对端路由器发送所需要的 LSA ,内容是多条 LSA (全部内容)的集合。

    (5)LSAck 报文( Link State Acknowledgment Packet ):用来对接收到的 DBD 、 LSU 报文进行确认。内容是需要确认的 LSA 的 HEAD (一个报文可对多个 LSA 进行确认)。

    7、0SPF路由配置

    (1)创建一个 OSPF 进程,进程号的范围为1~65535。

     Router ( config )# router ospf [ process - id ]

     (2)配置当前路由的 ID ,相当于每台路由器在 OSPF 中的名称,同一区域内不能相同,格式和 P 地址相同,都是点分十进制,取值范围为0.0.0.0~255.255.255.255。

     Router ( config - router )# router - id [ id - number ]

     (3)将直连网络发布到 OSPF 中,这里和 RIP 协议不同的地方在于,发布时需要添加所对应网段的反掩码和区域编号。

     Router ( config一router )# network network - address Wildcard - mask area -n umber

    二、拓扑图

    三、配置命令

    1、ZY-Router-1路由配置命令

    Router>enable 
    Router#conf terminal 
    Enter configuration commands, one per line. End with CNTL/Z.
    Router(config)#hostname ZY-Router-1
    ZY-Router-1(config)#interface fastEthernet 0/0
    ZY-Router-1(config-if)#ip address 192.31.10.1 255.255.255.0
    ZY-Router-1(config-if)#no shutdown 
    ZY-Router-1(config-if)#exit
    ZY-Router-1(config)#interface fastEthernet 0/1
    ZY-Router-1(config-if)#ip address 192.31.20.1 255.255.255.0
    ZY-Router-1(config-if)#no shutdown 
    ZY-Router-1(config-if)#exit 
    ZY-Router-1(config)#router ospf 100
    ZY-Router-1(config-router)#router-id 1.1.1.1
    ZY-Router-1(config-router)#network 192.31.10.0 0.0.0.255 area 0
    ZY-Router-1(config-router)#network 192.31.20.0 0.0.0.255 area 0

    2、ZY-Router-2路由配置命令

    Router>enable 
    Router#configure terminal 
    Enter configuration commands, one per line. End with CNTL/Z.
    Router(config)#hostname ZY-Router-2
    ZY-Router-2(config)#interface fastEthernet 0/0
    ZY-Router-2(config-if)#ip address 192.31.30.1 255.255.255.0
    ZY-Router-2(config-if)#no shutdown 
    ZY-Router-2(config-if)#exit
    ZY-Router-2(config)#interface fastEthernet 0/1
    ZY-Router-2(config-if)#ip address 192.31.20.2 255.255.255.0
    ZY-Router-2(config-if)#no shutdown 
    ZY-Router-2(config-if)#exit 
    ZY-Router-2(config)#router ospf 100
    ZY-Router-2(config-router)#router-id 2.2.2.2
    ZY-Router-2(config-router)#network 192.31.20.0 0.0.0.255 area 0
    ZY-Router-2(config-router)#network 192.31.30.0 0.0.0.255 area 0

    四、验证过程

    展开全文
  • 小游戏开发初衷

    千次阅读 2022-04-12 00:34:36
    在游戏过程中,还要考虑球的分布情况,在本区域或本营地的要优先搜索路径和选择,然后由近到远考虑公共区域或公共营地的两部分,最后是对面区域或对面营地的球。同一区域或营地内,球的数量比较少就要优先考虑,避免...
  • 该工作组成立于1998年,专门设计用于因特网的基于最短路径优先(SPF)算法的IGP。与IGRP类似,OSPF创建的原因是到了八十年代中期,RIP不能服务于大型、异构网络的缺陷愈发明显。本文介绍OSPF的路由环境、基础的路由...
  • 深入理解Java虚拟机-Java内存区域与内存溢出异常

    万次阅读 多人点赞 2020-01-03 21:42:24
    文章目录概述运行时数据区域程序计数器(线程私有)Java虚拟机栈(线程私有)局部变量表操作数栈动态链接方法返回地址小结本地方法栈(线程私有)Java堆(全局共享)方法区(全局共享)运行时常量池直接内存HotSpot...
  • OSPF个人总结 OSPF 介绍 OSPF(Open Shortest Path First)开放式最短路径优先协议: OSPF 网络类型 OSPF 报文 OSPF 状态机 OSPF LSA类型 OSPF 链路类型 OSPF 特殊区域
  • 敏捷开发之Scrum扫盲篇 现在敏捷开发是越来越火了,人人都在谈敏捷,人人都在学习Scrum和XP… 为了不落后他人,于是我也开始学习Scrum,今天主要是对我最近阅读的相关资料,根据自己的理解,用自己的话来讲述Scrum...
  • EF(Entity Framework)是微软实现数据库开发而构建的ORM框架,其开发模式有三种,Code First(代码优先),编写代码实体类,再生成相关数据库表对象Model First(模型优先),通过Visio Studio 构建模型,生成相关...
  • iOS开发Tap点击的区域问题。

    千次阅读 2016-06-16 13:20:00
    有点时候在开发的过程中,我们回遇到如下的情况,想通过点击北京阴影区域关闭掉弹出框,同时不希望点击弹出框区域弹出框消失。可以使用两种办法结决。 1. 给弹出框也加一个tap。根据响应事件的优先级。弹出框的...
  • Android 扩大View点击区域最好的方式

    千次阅读 2020-05-12 10:41:54
    Android 扩大View点击区域最好的方式先给结论实现介绍 先给结论 /** * 扩展点击区域的范围 * * @param view 需要扩展的元素,此元素必需要有父级元素 * @param expendSize 需要扩展的尺寸(以sp为单位的) */ ...
  • 、城市发展新区、生态涵养发展区四类功能区域外,首次设立“禁止开发区域”,并明确在该区域内,除必要 的交通、保护、修复、监测及科学实验设施外,禁止任何与资源保护无关的建设。 此次发布的主体功能
  • 嵌入式系统开发

    千次阅读 2021-08-12 15:27:07
    它允许ARM处理器的4GB地址空间定义8对域,分别控制8个指令和8个数据内存区域。 7种异常及相应优先级 经典ARM处理器有7种异常:复位RESET、未定义指令UND、 软件中断SWI、指令预取中止PABT、数据访问中止DABT、外部...
  • 开发市场的确是缺乏人才,市场需求大,但是开发不是随便就能做的,开发市场非常看重学历、毕业院校及项目能力。像985211的院校在大学中就是由老师带着参加各类项目,拥有项目实操能力。而普通的本科院校及专科院校都...
  • 敏捷开发流程总结

    万次阅读 多人点赞 2015-09-22 10:02:54
    Agile——敏捷开发,作为CMM神话崩溃后被引入的一套新的软件开发模式,这几年来被广泛引起关注,并被寄予厚望。敏捷开发在其他业界的应用是否理想不得而知,但以下总结了我所在公司的敏捷开发试验,希望可以达到...
  • OSPF的特征、术语、路由器类型、LSA类型、区域类型

    千次阅读 多人点赞 2022-04-09 14:34:11
    OSPF(Open Shortest Path First,开发最短链路优先)作为一种内部网关协议(Interior Gateway Protocl,IGP),用于在同一个自治系统(AS)中的路由器之间交换路由信息。OSPF的特征如下: 收敛速度快,适应规模较大...
  • Web前端开发规范手册

    千次阅读 多人点赞 2019-07-16 14:18:49
    链接不同状态设定特殊样式,影响被使用本样式区域中的链接。 该样式写法有2种: a.nav:link nav.a:link 第一种只能修饰a标签中;第二种可以修饰所有包含有a标签的其他标签。 页面内的样式加载必须用链接方式 ...
  • 如何快速学习VR开发,以及HTCvive的使用。
  • 嵌入式软件在需求规划、架构设计、变量定义、数据存储、显示界面设计、报警设计时,都...一旦冲突起来,比如两个变量的数值显示,改变同时发生,那哪个数值优先放到中心区域显示呢?这时就要对涉及到这些内容进行分级。
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    测试开发笔记 第一章 测试基础 7 什么是软件测试: 7 ★软件测试的目的、意义:(怎么做好软件测试) 7 3.软件生命周期: 7 第二章 测试过程 8 1.测试模型 8 H模型: 8 V模型 9 2.内部测试 10 3外部测试: 10 验收...
  • Java高级开发岗位笔试题和解析(一)

    万次阅读 2020-04-14 09:11:22
    对象在JVM堆中的生命周期分为新生代、老年代、永久代 新创建的对象默认优先分配到新生代Eden区,新生代主要有三块区域组成:Eden、Survivor S0(from)、Survivor S1(to) 新生代管理对象生命周期主要是使用复制算法...
  • Android平台为我们开发应用程序提供了一套很好的框架,我们可以在这个平台的基础上开发不同的应用程序,也可以开发新的组件供应用程序调用。 3.1  Android架构 Android的架构是Linux内核、C/C++函数库、...
  • 什么是敏捷开发

    万次阅读 多人点赞 2017-09-19 14:14:27
    现在敏捷开发是越来越火了,人人都在谈敏捷,人人都在学习Scrum和XP...   为了不落后他人,于是我也开始学习Scrum,今天主要是对我最近阅读的相关资料,根据自己的理解,用自己的话来讲述Scrum中的各个环节,...
  • WPF开发教程

    万次阅读 多人点赞 2019-07-02 23:13:20
    ------WPF开发教程 目录 WPF基础入门.... 3 1. WPF基础之体系结构... 3 2. WPF基础之XAML. 9 3. WPF基础之基元素... 23 4. WPF基础之属性系统... 26 5. WPF基础之路由事件... 33 6. WPF基础之布局系统... ...
  • STM32开发 -- 启动流程

    万次阅读 多人点赞 2018-06-05 20:14:33
    启动模式讲完了,我们知道是主闪存存储器启动的。主闪存存储器被映射到启动空间(0x0000 0000),但仍然能够在...参看:DM368开发 – Bootloader 开发(转毕设) BUT,我真的还是讲不明白。还是没有理解透,过一段...
  • MDCC 2016 中国移动开发者大会前夕,iOS 开发峰会演讲嘉宾——搜狗输入法 iOS 版负责人李腾杰接受 CSDN 专访,分享了其与团队在第三方输入法开发与优化方面的经验,以及搜狗输入法 iOS 版开发团队在新技术与一线项目...
  • autojs 开发文档集合

    千次阅读 2020-09-28 10:52:33
    教程会优先发布于收费脚本v群。 该代码选自于aj开发者的文档,群里有人反馈开发文档打开慢.所以做了这个.方便搜索.如有侵权,请私信我进行删除 同时也上传了一份源码到点击网站,供大家更快的查询代码 Auto.js Pro-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,800
精华内容 27,520
关键字:

优先开发区域