Go语言的编程范式

由于比较古怪的语言特性,感觉代码的封装性是一种不同的思路。

包管理的火热程度居然没有nodejs高,这是为什么

package form

import (
    "encoding/gob"
    "reflect"
    "regexp"
    "time"
)

type FormData struct {
    Errors  map[string]error  `json:"-" xml:"-" form:"-"`
    Warning map[string]string `json"-" xml:"-" form: "-"`
    Checked bool              `json"-" xml:"-" form: "-"`
}

// Use that as an amonynous field for creating form.
type Form struct {
    Data *FormData
}

// Get Error
func (f *Form) Err(name string) error {
    if f.Data == nil {
        return nil
    }
    if f.Data.Errors == nil {
        return nil
    }
    return f.Data.Errors[name]
}

// Set Error
func (f *Form) SetErr(name string, err error) {
    if f.Data == nil {
        f.Data = &FormData{}
    }
    if f.Data.Errors == nil {
        f.Data.Errors = map[string]error{}
    }
    f.Data.Errors[name] = err
}

// Has at least one Error
func (f *Form) HasErr() bool {
    if f.Data == nil {
        return false
    }
    return f.Data.Errors != nil
}

// Returns Error Format.
func (f *Form) ErrFormat() string {
    return `<p>%v</p>`
}

// Get Warning
func (f *Form) GetWarning(name string) string {
    if f.Data == nil {
        return ""
    }
    if f.Data.Warning == nil {
        return ""
    }
    return f.Data.Warning[name]
}

// Set Warning
func (f *Form) SetWarning(name, warning string) {
    if f.Data == nil {
        f.Data = &FormData{}
    }
    if f.Data.Warning == nil {
        f.Data.Warning = map[string]string{}
    }
    f.Data.Warning[name] = warning
}

// Returns Warning Format
func (f *Form) WarningFormat() string {
    return `<p>%v</p>`
}

// Return Group Format
func (f *Form) Group() string {
    return `%v`
}

// Return Group Format Success
func (f *Form) GroupSuccess() string {
    return `%v`
}

// Return Group Error Format
func (f *Form) GroupError() string {
    return `%v`
}

// Return Group Warning Format
func (f *Form) GroupWarning() string {
    return `%v`
}

// Wrap around Form Input
func (f *Form) Wrap() string {
    return `%v`
}

// Been Checked
func (f *Form) BeenChecked() bool {
    if f.Data == nil {
        return false
    }
    return f.Data.Checked
}

// Mark as Checked
func (f *Form) Check() {
    if f.Data == nil {
        f.Data = &FormData{}
    }
    f.Data.Checked = true
}

// Form Interface
type FormInterface interface {
    Err(string) error
    SetErr(string, error)
    HasErr() bool
    ErrFormat() string
    GetWarning(string) string
    SetWarning(string, string)
    WarningFormat() string
    Group() string
    GroupSuccess() string
    GroupError() string
    GroupWarning() string
    Wrap() string
    BeenChecked() bool
    Check()
}

// A String that implement the error interface
type FormError string

func (f FormError) Error() string {
    return string(f)
}

func init() {
    gob.Register(&Form{})
    gob.Register(FormError(""))
    gob.Register(&FormData{})
}

type form struct {
    m                         reflect.Value
    t                         reflect.Type
    v                         reflect.Value
    field                     reflect.StructField
    value                     reflect.Value
    name, preferedName, ftype string
}

func (f form) get(suffix string) interface{} {
    m := f.m.MethodByName(f.name + suffix)
    if !m.IsValid() {
        return nil
    }
    in := make([]reflect.Value, 0)
    values := m.Call(in)
    if len(values) == 0 {
        return nil
    }
    return values[0].Interface()
}

func (f form) getStr(suffix string) (string, bool) {
    str, ok := f.get(suffix).(string)
    return str, ok
}

func (f form) getStrs(suffix string) ([]string, bool) {
    strs, ok := f.get(suffix).([]string)
    return strs, ok
}

func (f form) getStrMap(suffix string) (map[string]string, bool) {
    mstr, ok := f.get(suffix).(map[string]string)
    return mstr, ok
}

func (f form) getInt(suffix string) (int64, bool) {
    num, ok := f.get(suffix).(int64)
    return num, ok
}

func (f form) getFloat(suffix string) (float64, bool) {
    num, ok := f.get(suffix).(float64)
    return num, ok
}

func (f form) getBool(suffix string) (bool, bool) {
    b, ok := f.get(suffix).(bool)
    return b, ok
}

func (f form) getRegExp(suffix string) (*regexp.Regexp, bool) {
    re, ok := f.get(suffix).(*regexp.Regexp)
    return re, ok
}

func (f form) getTime(suffix string) (time.Time, bool) {
    _time, ok := f.get(suffix).(time.Time)
    return _time, ok
}
时间: 2024-10-23 16:19:45

Go语言的编程范式的相关文章

编程范式与语言

这篇文章是应“编程新思路”COP小组之邀,对编程范式做一个专题分享.主要是自己在读书.学习.工作上的一些心得总结,能力有限,希望能抛砖引玉,一同探讨. 为什么要了解编程范式和语言 到目前为止,世界上约有2500种程序设计语言,其中一部分的族谱关系如下. 语言从世界观上思考和影响软件设计,不同范式看待设计的角度也迥然不同,比如命令范式语言以状态(变量)抽象现实世界,对象范式语言以对象对象现实世界,函数范式语言以计算(函数)抽象现实时间.对现实问题的不同观察视角,从根本上影响软件开发者的思考方式和对

再谈编程范式—程序语言背后的思想

编程范式 托马斯.库尔提出“科学的革命”的范式论后,Robert Floyd在1979年图灵奖的颁奖演说中使用了编程范式一词.编程范式一般包括三个方面,以OOP为例: 1,学科的逻辑体系——规则范式:如 类/对象.继承.动态绑定.方法改写.对象替换等等机制. 2,心理认知因素——心理范式:按照面向对象编程之父Alan Kay的观点,“计算就是模拟”.OO范式极其重视隐喻(metaphor)的价值,通过拟人化,按照自然的方式模拟自然. 3,自然观/世界观——观念范式:强调程序的组织技术,视程序为松

【编程范式】C语言1

最近在网易公开课上看斯坦福大学的<编程范式>,外国人讲课思路就是清晰,上了几节课,感觉难度确实比我们普通大学大很多,但是却很有趣,让人能边学边想. 范式编程,交换两个数,利用 void * void Swap (void * lhs,void * rhs,int size) { void * temp = malloc(sizeof(size)); memmove(temp,lhs,sizeof(size)); memmove(lhs,rhs,sizeof(size));  memmove(r

编程范式

编程范式(Programming Paradigm)是某种编程语言典型的编程风格或者说是编程方式.随着编程方法学和软件工程研究的深入,特别是OO思想的普及,范式(Paradigm)以及编程范式等术语渐渐出现在人们面前.面向对象编程(OOP)常常被誉为是一种革命性的思想,正因为它不同于其他的各种编程范式.编程范式也许是学习任何一门编程语言时要理解的最重要的术语. 托马斯.库恩提出“科学的革命”的范式论之后,Robert Floyd在1979年图灵奖的颁奖演说中使用了编程范式一词.编程范式一般包括三

【冒号课堂】【阅读笔记】编程范式整理

编程范式 命令式/过程式(Imperative/Procedural) 代表语言 Fortran/Pascal/C 核心概念 命令/过程(Command/Procedure) 运行机制 命令执行 关键突破 突破单一主程序和非结构话程序的限制 实现原理 引入逻辑控制与子程序 主要目的 模拟机器思维,实现自顶向下的模块设计 常见应用 交互式.事件驱动型系统.数值计算等 编程范式 函数式/应用式(Functional/Applicative) 代表语言 Scheme/Haskell 核心概念 函数(F

jQuery中的编程范式

浏览器前端编程的面貌自2005年以来已经发生了深刻的变化,这并不简单的意味着出现了大量功能丰富的基础库,使得我们可以更加方便的编写业务代码,更重要的是我们看待前端技术的观念发生了重大转变,明确意识到了如何以前端特有的方式释放程序员的生产力.本文将结合jQuery源码的实现原理,对javascript中涌现出的编程范式和常用技巧作一简单介绍.    1. AJAX: 状态驻留,异步更新      首先来看一点历史. A. 1995年Netscape公司的Brendan Eich开发了javacri

Scala函数式编程设计原理 第一课 编程范式(Programming Paradigms)

我使用Scala有一两年的时间了,这门语言仿佛有一种魔力,让人用过就不想放手.Scala给我的整个程序生涯带来了非常深刻的影响,让我学会了函数式编程,让我知道了世界上居然还有这么一种优雅.高效.强大的语言. Scala在国外已经非常流行,但是不知为何,在国内总是不温不火,在此,我特别想为Scala这门语言在国内的发展做一些事情.不才不敢谈Scala的编程经验,因为要成为Scala大神还有很长的路要走,只好翻译一份Scala视频教程以飨读者,大家发现有误的地方,请多多批评指教. 这个视频的作者是S

聊聊编程范式

编程语言有很多种流派和思想,有一些编程语言同时支持多种编程范式. 静态类型编程范式 采用静态类型编程范式的编程语言,其变量需要明确指定类型.代表语言:C,C++,Pascal,Objective-C,Java,C#,VB.NET,Swif,Golang. 这样做的好处是: 1.编译器可以在编译时就能找出类型错误. 2.编译器编译时知道类型信息,就可以提高性能. 这种范式认为,程序员肯定知道变量的类型,你丫要是不知道变量的类型,那你就别混了!编译时,程序会报错. Swift和Go语言都是静态类型编

函数式编程范式

函数式编程语言有个特点是没有变量,python部分支持函数式编程范式,但不是纯函数式语言. 什么是函数式编程?简单的回答:一切都是数学函数.函数式编程语言里也可以有对象,但通常这些对象都是恒定不变的 —— 要么是函数参数,要什么是函数返回值.函数式编程语言里没有 for/next 循环,因为这些逻辑意味着有状态的改变.相替代的是,这种循环逻辑在函数式编程语言里是通过递归.把函数当成参数传递的方式实现的. 对于为什么要使用函数式编程,这有一个更好的论据,现代的应用程序都会牵涉到多核计算机上的并行运