Python 函数参数魔法

事情的起因是感觉目前项目中的参数校验方法写的太简单了,很多时候需要在server层再if else处理,于是就动手准备写一个好用一点的,可以自定义校验参数规则的参数校验器,考虑到要可以灵活的配置就萌生了大概的印象:

  1. 使用map - 参数A:ruleA,参数B-ruleB..等等,对参数进行规则绑定
  2. 使用装饰器
  3. 可扩展,可以自定义校验规则

于是第一个版本实现如下:

版本1


  2. # -*- coding:utf-8 -*-
  3. __author__ = "aleimu"
  4. __date__ = "2018-12-6"
  5. __doc__ = "一个实用的入参校验装饰器--针对目前,前端 url?&a=1&b=2或-d'a=1&b=2c=qwe'形式的非json(所有参数都是str类型)" \
  6.           "入参的校验"
  8. import copy
  9. import traceback
  10. from collections import OrderedDict
  11. from functools import wraps
  12. from flask import Flask, json, jsonify, request
  14. app = Flask(__name__)
  16. def verify_args(need=None, length=None, check=None, strip=True, default=(False, None), diy_func=None, release=False):
  17.     """
  18.     约束:
  19.     1. 简化了传参校验,使用位置传参或者关键词传参(一个参数对应一个参数),不允许使用one to list等python高级传参特性
  20.     2. 所有的参数都是str/unicode类型的,前端没有使用json带参数类型的入参方式
  21.     :param need: 必须参数,且不能为None或者""
  22.     :param length: 参数长度范围
  23.     :param check:  str的常用类方法/属性如下:
  24.         isalnum 判断字符串中只能由字母和数字的组合，不能有特殊符号
  25.         isalpha 字符串里面都是字母，并且至少是一个字母，结果就为真，（汉字也可以）其他情况为假
  26.         isdigit 函数判断是否全为数字
  27.     :param strip:对字段进行前后过滤空格
  28.     :param default:将"" 装换成None
  29.     :param diy_func:自定义的对某一参数的校验函数格式: {key:func},类似check, diy_func={"a": lambda x: x + "aa"})
  30.     :param release:发生参数校验异常后是否依然让参数进入主流程函数
  31.     :return:
  32.     """
  34.     def wraps_1(f):
  35.         @wraps(f)
  36.         def wraps_2(*args, **kwargs):
  37.             if release:
  38.                 args_bak = args[:]
  39.                 kwargs_bak = copy.deepcopy(kwargs)  # 下面流程异常时,是否直接使用 原参数传入f todo
  40.             print ("in", args, kwargs)
  41.             args_template = f.func_code.co_varnames
  42.             print("args_template:", args_template)
  43.             args_dict = OrderedDict()
  44.             req_args_need_list = []
  45.             req_args_types_list = []
  46.             try:
  47.                 for i, x in enumerate(args):
  48.                     args_dict[args_template[i]] = x
  49.                 sorted_kwargs = sort_by_co_varnames(args_template, kwargs)
  50.                 args_dict.update(sorted_kwargs)
  51.                 print("args_dict:", args_dict)
  52.                 # need
  53.                 if need:
  54.                     for k in need:
  55.                         if k not in args_dict:
  56.                             req_args_need_list.append(k)
  57.                         else:
  58.                             if args_dict[k] == None or args_dict[k] == "":
  59.                                 req_args_need_list.append(k)
  60.                     if req_args_need_list:
  61.                         return False, "%s is in need" % req_args_need_list
  62.                 # strip
  63.                 if strip:
  64.                     for k in args_dict:
  65.                         if args_dict[k]:
  66.                             args_dict[k] = args_dict[k].strip()
  67.                 # length
  68.                 if length:
  69.                     for k in args_dict:
  70.                         if k in length:
  71.                             if not (len(args_dict[k]) >= length[k][0] and len(args_dict[k]) <= length[k][1]):
  72.                                 return False, "%s length err" % k
  73.                 # default:
  74.                 if default[0]:
  75.                     for x in args_dict:
  76.                         if args_dict[x] == "":
  77.                             args_dict[x] = default[1]
  78.                 # check
  79.                 if check:
  80.                     for k in check:
  81.                         check_func = getattr(type(args_dict[k]), check[k], None)
  82.                         if not (k in args_dict and check_func and check_func(args_dict[k])):
  83.                             req_args_types_list.append(k)
  84.                     if req_args_types_list:
  85.                         return False, "%s type err" % req_args_types_list
  86.                 # diy_func
  87.                 if diy_func:
  88.                     for k in args_dict:
  89.                         if k in diy_func:
  90.                             args_dict[k] = diy_func[k](args_dict[k])
  91.             except Exception as e:
  92.                 print("verify_args catch err: ", traceback.format_exc())
  93.                 if release:
  94.                     return f(*args_bak, **kwargs_bak)
  95.                 else:
  96.                     return False, str(e)
  97.             return f(*args_dict.values())
  99.         return wraps_2
  101.     return wraps_1
  103. def sort_by_co_varnames(all_args, kwargs):
  104.     new_ordered = OrderedDict()
  105.     for x in all_args:
  106.         if x in kwargs:
  107.             new_ordered[x] = kwargs[x]
  108.     return new_ordered
  110. @app.route("/", methods=["GET", "POST", "PUT"])
  111. def index():
  112.     a = request.values.get("a")
  113.     b = request.values.get("b")
  114.     c = request.values.get("c")
  115.     d = request.values.get("d")
  116.     e = request.values.get("e")
  117.     f = request.values.get("f")
  118.     g = request.values.get("g")
  119.     status, data = todo(a, b, c, d, e=e, f=f, g=g)
  120.     if status:
  121.         return jsonify({"code": 200, "data": data, "err": None})
  122.     else:
  123.         return jsonify({"code": 500, "data": None, "err": data})
  125. @verify_args(need=['a', 'b', 'c'], length={"a": (6, 50)}, strip=True,
  126.              check={"b": 'isdigit', "c": "isalnum"},
  127.              default=(True, None),
  128.              diy_func={"a": lambda x: x + "aa"})
  129. def todo(a, b, c, d, e='  1  ', f='2    ', g=''):
  130.     return True, {"a": a, "b": b, "c": c, "d": d, "e": e, "f": f, "g": g}
  132. if __name__ == "__main__":
  133.     app.run(host='0.0.0.0', port=6000, debug=True)
  135. """
  136. # curl "http://127.0.0.1:6000/" -d "pwd=123&a=1111111&b=2&c=3&d=d&e=eeeeee&f=12345&g="
  137. {
  138.   "code": 200,
  139.   "data": {
  140.     "a": "1111111aa",
  141.     "b": "2",
  142.     "c": "3",
  143.     "d": "d",
  144.     "e": "eeeeee",
  145.     "f": "12345",
  146.     "g": null
  147.   },
  148.   "err": null
  149. }
  151. # curl "http://127.0.0.1:6000/" -d "pwd=123&a=1111111&b=2&c=3346()*&d=d&e=eeeeee&f=12345&g="
  152. {
  153.   "code": 500,
  154.   "data": null,
  155.   "err": "['c'] type err"
  156. }
  158. # curl "http://127.0.0.1:6000/" -d "pwd=123&a=1111111&b=2&c=&d=d&e=eeeeee&f=12345&g="
  159. {
  160.   "code": 500,
  161.   "data": null,
  162.   "err": "['c'] is in need"
  163. }   
  165. # curl "http://127.0.0.1:6000/" -d "pwd=123&a=1111111&b=2&c=  1  &d=d&e=eeeeee&f=12345&g="
  166. {
  167.   "code": 200,
  168.   "data": {
  169.     "a": "1111111aa",
  170.     "b": "2",
  171.     "c": "1",
  172.     "d": "d",
  173.     "e": "eeeeee",
  174.     "f": "12345",
  175.     "g": null
  176.   },
  177.   "err": null
  178. }
  179. """

第一个版本切合了当前项目中经常遇到的校验问题,实现起来较简单,基本满足要求.
想要更通用点,更多校验规则一些,就需要每次为verify_args添加参数写if else了,嗯.....有点不优雅啊,于是去看github上有啥好的实现.
找到了如下几个项目:

  1. https://github.com/keleshev/s... 嗯,1.6K的star,思路一致,实现的优雅,但是不好扩展啊....
  2. https://github.com/kvesteri/v... 额,Python Data Validation for Humans™. not for me....
  3. https://github.com/mansam/val... 嗯,思路一致,实现也简单,挺好扩展的,就用它了!

这里说说validator.py ,给个例子


  2. from validator import Required, Not, Truthy, Blank, Range, Equals, In, validate
  4. # let's say that my dictionary needs to meet the following rules...
  5. rules = {
  6.     "foo": [Required, Equals(123)],
  7.     "bar": [Required, Truthy()],
  8.     "baz": [In(["spam", "eggs", "bacon"])],
  9.     "qux": [Not(Range(1, 100))] # by default, Range is inclusive
  10. }
  12. # then this following dict would pass:
  13. passes = {
  14.     "foo": 123,
  15.     "bar": True, # or a non-empty string, or a non-zero int, etc...
  16.     "baz": "spam",
  17.     "qux": 101
  18. }
  19. print validate(rules, passes)
  20. # (True, {})
  22. # but this one would fail
  23. fails = {
  24.     "foo": 321,
  25.     "bar": False, # or 0, or [], or an empty string, etc...
  26.     "baz": "barf",
  27.     "qux": 99
  28. }
  29. print validate(rules, fails)
  30. # (False,
  31. #  {
  32. #  'foo': ["must be equal to '123'"],
  33. #  'bar': ['must be True-equivalent value'],
  34. #  'baz': ["must be one of ['spam', 'eggs', 'bacon']"],
  35. #  'qux': ['must not fall between 1 and 100']
  36. #  })

嗯,使用第一个版本封装一下validator.py就好了!考虑到需要写个dome来试试,就选了flask,嗯,对了,先去github 上搜一下 flask validator 没准已经有现成的呢,实现思路基本一致,但是......前几个star多的都不令人满意,还是自己造轮子吧.
先实现常见的在route上加装饰器版本,这样的话,就可以直接接收request收到的参数,然后直接校验了,有问题就直接返回错误给调用者,于是有了版本2

版本2


  2. rules_example = {
  3.     "a": [Required, Equals("123")],  # foo must be exactly equal to 123
  4.     "b": [Required, Truthy()],  # bar must be equivalent to True
  5.     "c": [In(["spam", "eggs", "bacon"])],  # baz must be one of these options
  6.     "d": [Not(Range(1, 100))],  # qux must not be a number between 1 and 100 inclusive
  7.     "e": [Length(0, maximum=5)],
  8.     "f": [Required, InstanceOf(str)],
  9.     "g": [Required, Not(In(["spam", "eggs", "bacon"]))],
  10.     "h": [Required, Pattern("\d\d\%")],
  11.     "i": [Required, GreaterThan(1, reverse=True, auto=True)],  # auto 自动转换成float类型来做比较
  12.     "j": [lambda x: x == "bar"],
  13.     "k": [Required, Isalnum()],  # 判断字符串中只能由字母和数字的组合，不能有特殊符号
  14.     "l": [Required, Isalpha()],  # 字符串里面都是字母，并且至少是一个字母，结果就为真，（汉字也可以）其他情况为假
  15.     "m": [Required, Isdigit()],  # 判断字符串是否全为数字
  16. }
  18. def validator_wrap(rules, strip=True, diy_func=None):
  19.     """装饰器版 - 只能检测是否符合规则,不能修改参数
  20.     :param rules:参数的校验规则,map
  21.     :param strip:对字段进行前后空格检测
  22.     :param diy_func:自定义的对某一参数的校验函数格式: {key:func},类似check, diy_func={"a": lambda x: x=="aa"})
  23.     """
  25.     def decorator(f):
  26.         @wraps(f)
  27.         def decorated_func(*args, **kwargs):
  28.             try:
  29.                 args_dict = OrderedDict()
  30.                 if request.values:
  31.                     args_dict.update(request.values)
  32.                 if request.json:
  33.                     args_dict.update(request.json)
  34.                 # strip
  35.                 if strip:
  36.                     for k in args_dict:
  37.                         if args_dict[k] and isstr(args_dict[k]):
  38.                             if args_dict[k][0] == " " or args_dict[k][-1] == " ":
  39.                                 return jsonify({"code": 500, "data": None, "err": "%s should not contain spaces" % k})
  40.                 # diy_func
  41.                 if diy_func:
  42.                     for k in args_dict:
  43.                         if k in diy_func:
  44.                             args_dict[k] = diy_func[k](args_dict[k])
  45.                 # rules
  46.                 if rules:
  47.                     result, err = validate(rules, args_dict)
  48.                     if not result:
  49.                         return jsonify(
  50.                             {"code": 500, "data": None, "err": err})
  51.             except Exception as e:
  52.                 print("verify_args catch err: ", traceback.format_exc())
  53.                 return jsonify({"code": 500, "data": None, "err": str(e)})
  54.             return f(*args, **kwargs)
  56.         return decorated_func
  58.     return decorator
  60. @app.route("/wrap", methods=["GET", "POST", "PUT"])
  61. @validator_wrap(rules=rules_example, strip=True)  # 姿势 1:只能检测是否符合规则,不能修改参数,不符合就会直接返回json给调用者
  62. def wrap_example():
  63.     a = request.values.get("a")
  64.     b = request.values.get("b")
  65.     c = request.values.get("c")
  66.     d = request.values.get("d")
  67.     e = request.values.get("e")
  68.     f = request.values.get("f")
  69.     g = request.values.get("g")
  70.     h = request.values.get("h")
  71.     i = request.values.get("i")
  72.     j = request.values.get("j")
  73.     k = request.values.get("k")
  74.     l = request.values.get("l")
  75.     m = request.values.get("m")
  76.     status, data = todo(a=a, b=b, c=c, d=d, e=e, f=f, g=g, h=h, i=i, j=j, k=k, l=l, m=m)
  77.     if status:
  78.         return jsonify({"code": 200, "data": data, "err": None})
  79.     else:
  80.         return jsonify({"code": 500, "data": None, "err": data})

好像挺好的,基本满足要求了,但是再route上加装饰器,那就改变不了参数的值了,虽然有些参数不一定符合要求,但是简单修补一下还是可以用的,还得继续寻找能够改变入参的方式,第一反应是在装饰器中修改request.values或者request.json的值,让进入到主函数后获取更新后的值,上下求索未得门径,request.value.update方法是被禁用的,继续看源码,后面的实现使用了dict的复杂封装,不好改啊,这样太绕了,还是直接调用函数吧,不玩装饰器了.于是又了版本3

版本3


  2. def validator_func(rules, strip=True, default=(False, None), diy_func=None, release=False):
  3.     """函数版-返回dict,代替request.values/request.json
  4.     :param rules:参数的校验规则,map
  5.     :param strip:对字段进行前后过滤空格
  6.     :param default:将"" 装换成None
  7.     :param diy_func:自定义的对某一参数的校验函数格式: {key:func},类似check, diy_func={"a": lambda x: x + "aa"})
  8.     :param release:发生参数校验异常后是否依然让参数进入主流程函数
  9.     """
  10.     args_dict = OrderedDict()
  11.     try:
  12.         if request.values:
  13.             args_dict.update(request.values)
  14.         if request.json:
  15.             args_dict.update(request.json)
  16.         if release:
  17.             args_dict_copy = copy.deepcopy(args_dict)  # 下面流程异常时,是否直接使用 原参数传入f # fixme
  18.         # strip
  19.         if strip:
  20.             for k in args_dict:
  21.                 if isstr(args_dict[k]):
  22.                     args_dict[k] = args_dict[k].strip()
  23.         # default
  24.         if default[0]:
  25.             for x in args_dict:
  26.                 if args_dict[x] == "":
  27.                     args_dict[x] = default[1]
  28.         # diy_func
  29.         if diy_func:
  30.             for k in args_dict:
  31.                 if k in diy_func:
  32.                     args_dict[k] = diy_func[k](args_dict[k])
  33.         # rules
  34.         if rules:
  35.             result, err = validate(rules, args_dict)
  36.             if not result:
  37.                 return False, err
  38.     except Exception as e:
  39.         print("verify_args catch err: ", traceback.format_exc())  # TODO
  40.         if release:
  41.             return True, args_dict_copy
  42.         else:
  43.             return False, str(e)
  44.     return True, args_dict
  46. @app.route("/func", methods=["GET", "POST", "PUT"])
  47. def func_example():
  48.     result, request_args = validator_func(rules=rules_example, strip=True)  # 姿势 2
  49.     if not result:
  50.         return jsonify({"code": 500, "data": None, "err": request_args})
  51.     a = request_args.get("a")
  52.     b = request_args.get("b")
  53.     c = request_args.get("c")
  54.     d = request_args.get("d")
  55.     e = request_args.get("e")
  56.     f = request_args.get("f")
  57.     g = request_args.get("g")
  58.     h = request_args.get("h")
  59.     i = request_args.get("i")
  60.     j = request_args.get("j")
  61.     k = request_args.get("k")
  62.     l = request_args.get("l")
  63.     m = request_args.get("m")
  64.     status, data = todo(a=a, b=b, c=c, d=d, e=e, f=f, g=g, h=h, i=i, j=j, k=k, l=l, m=m)
  65.     if status:
  66.         return jsonify({"code": 200, "data": data, "err": None})
  67.     else:
  68.         return jsonify({"code": 500, "data": None, "err": data})

嗯,还行吧,就是不怎么优雅,还是有点喜欢装饰器版本,但是苦于能力有限,不想看ImmutableMultiDict,MultiDict的实现,还是将第一个版本融合一下吧,装饰route不行,装饰todo还不行吗.于是有了版本4

版本4


  2. def validator_args(rules, strip=True, default=(False, None), diy_func=None, release=False):
  3.     """针对普通函数的参数校验的装饰器
  4.     :param rules:参数的校验规则,map
  5.     :param strip:对字段进行前后过滤空格
  6.     :param default:将"" 装换成None
  7.     :param diy_func:自定义的对某一参数的校验函数格式: {key:func},类似check, diy_func={"a": lambda x: x + "aa"})
  8.     :param release:发生参数校验异常后是否依然让参数进入主流程函数
  9.     """
  11.     def decorator(f):
  12.         @wraps(f)
  13.         def decorated_func(*args, **kwargs):
  14.             if release:
  15.                 args_bak = args[:]
  16.                 kwargs_bak = copy.deepcopy(kwargs)  # 下面流程异常时,是否直接使用 原参数传入f # fixme
  17.             try:
  18.                 args_template = f.func_code.co_varnames
  19.             except:
  20.                 args_template = f.__code__.co_varnames
  21.             args_dict = OrderedDict()
  22.             try:
  23.                 for i, x in enumerate(args):
  24.                     args_dict[args_template[i]] = x
  25.                 sorted_kwargs = sort_by_co_varnames(args_template, kwargs)
  26.                 args_dict.update(sorted_kwargs)
  27.                 # strip
  28.                 if strip:
  29.                     for k in args_dict:
  30.                         if isstr(args_dict[k]):
  31.                             args_dict[k] = args_dict[k].strip()
  32.                 # default
  33.                 if default[0]:
  34.                     for x in args_dict:
  35.                         if args_dict[x] == "":
  36.                             args_dict[x] = default[1]
  37.                 # diy_func
  38.                 if diy_func:
  39.                     for k in args_dict:
  40.                         if k in diy_func:
  41.                             args_dict[k] = diy_func[k](args_dict[k])
  42.                 # rules
  43.                 if rules:
  44.                     result, err = validate(rules, args_dict)
  45.                     if not result:
  46.                         return False, err
  47.             except Exception as e:
  48.                 print("verify_args catch err: ", traceback.format_exc())
  49.                 if release:
  50.                     return f(*args_bak, **kwargs_bak)
  51.                 else:
  52.                     return False, str(e)
  53.             return f(*args_dict.values())
  55.         return decorated_func
  57.     return decorator
  59. @validator_args(rules=rules_example, strip=True)  # 姿势 3
  60. def todo(a, b, c, d, e, f, g, h, i, j, k, l, m):
  61.     return True, {"a": a, "b": b, "c": c, "d": d, "e": e, "f": f, "g": g, "h": h, "i": i, "j": j, "k": k, "l": l,
  62.                   "m": m}

哎,就这样吧,打包一下,随便选吧,爱用哪个用哪个,反正我都写出来了.简单说就是:

  1. validator_func 针对flask的request.json/requests.values的参数校验以及修改,修改的方式有限,可以自己控制
  2. validator_wrap 是针对flask route的装饰器,针对request.json/requests.values的参数校验,只是校验,当然校验的方式可以自己写扩展
  3. validator_args 针对普通函数的参数校验以及修改,注意不要使用python传参的高级特性(一个参数对应多个值),这个方法可以脱离flask使用,所以如果需要就直接copy过去吧.

嗯,最后还是分享一下到git上吧, https://github.com/aleimu/flask-validator 喜欢的点个star.

Python 参数校验的进化的更多相关文章

  1. python项目使用jsonschema进行参数校验

    python项目使用jsonschema进行参数校验 最近想要给一个新的openstack项目加上参数校验,过完年回来准备开工的时候,发现其他人已经在做了,对应的patch是:https://revi ...

  2. java自定义注解实现前后台参数校验

    2016.07.26 qq:992591601,欢迎交流 首先介绍些基本概念: Annotations(also known as metadata)provide a formalized way ...

  3. jQuery form插件的使用--用 formData 参数校验表单，验证后提交（简单验证）.

    Form Plugin API 里提供了很多有用的方法可以让你轻松的处理表单里的数据和表单的提交过程. 测试环境:部署到Tomcat中的web项目. 一.引入依赖js <script src=& ...

  4. SpringMVC参数校验（针对`@RequestBody`返回`400`）

    SpringMVC参数校验(针对@RequestBody返回400) 前言 习惯别人帮忙做事的结果是自己不会做事了.一直以来,spring帮我解决了程序运行中的各种问题,我只要关心我的业务逻辑,设计好 ...

  5. Spring Boot 参数校验

    1.背景介绍 开发过程中,后台的参数校验是必不可少的,所以经常会看到类似下面这样的代码 这样写并没有什么错,还挺工整的,只是看起来不是很优雅而已. 接下来,用Validation来改写这段 2.Spr ...

  6. 【spring】-- jsr303参数校验器

    一.为什么要进行参数校验? 当我们在服务端控制器接受前台数据时,肯定首先要对数据进行参数验证,判断参数是否为空?是否为电话号码?是否为邮箱格式?等等. 这里有个问题要注意: 前端代码一般上会对这些数据 ...

  7. 补习系列(4)-springboot 参数校验详解

    目录 目标 一.PathVariable 校验 二.方法参数校验 三.表单对象校验 四.RequestBody 校验 五.自定义校验规则 六.异常拦截器 参考文档 目标 对于几种常见的入参方式,了解如 ...

  8. Spring基础系列-参数校验

    原创作品,可以转载,但是请标注出处地址:https://www.cnblogs.com/V1haoge/p/9953744.html Spring中使用参数校验 概述 ​ JSR 303中提出了Bea ...

  9. Java笔记 #06# 自定义简易参数校验框架——EasyValidator

    索引 一.校验效果演示 二.校验器定义示例 定义一个最简单的校验器 正则校验器 三.EasyValidator的实现 四.更好的应用姿势——配合注解和面向切面 “参数校验”属于比较无聊但是又非常硬性的 ...

随机推荐

  1. Codeforces 551E GukiZ and GukiZiana（分块思想）

    题目链接 GukiZ and GukiZiana 题目大意:一个数列,支持两个操作.一种是对区间$[l, r]$中的数全部加上$k$,另一种是查询数列中值为$x$的下标的最大值减最小值. $n < ...

  2. 线程池之ThreadPoolExecutor线程池源码分析笔记

    1.线程池的作用 一方面当执行大量异步任务时候线程池能够提供较好的性能,在不使用线程池的时候,每当需要执行异步任务时候是直接 new 一线程进行运行,而线程的创建和销毁是需要开销的.使用线程池时候,线 ...

  3. Android View 绘制流程(Draw) 完全解析

    前言 前几篇文章,笔者分别讲述了DecorView,measure,layout流程等,接下来将详细分析三大工作流程的最后一个流程——绘制流程.测量流程决定了View的大小,布局流程决定了View的位 ...

  4. standford情感分析代码开源地址

    http://nlp.stanford.edu/sentiment/code.html

  5. IDG | 四则运算表达式计算

    分析 首先将中缀表达式转换为后缀表达式(逆波兰式),然后使用栈进行计算. 没有考虑括号.小数. 代码 import java.util.LinkedList; import java.util.Lis ...

  6. react 自定义 TabBar 组件

    1.创建 组件 src/components/TabBar/index.js /** * TabBar 组件 */ import React ,{ PureComponent } from 'reac ...

  7. react 调用 function 的写法 及 解决 react onClick 方法自动执行

    1.react 调用方法的写法 (1)方式一 onClick={this.getFetchData.bind(this,item.id)} (2)方式二 getFetchData(e){ this.s ...

  8. Odoo 运费

    模块delievery可以将运费Charge给客户     安装delivery模块                 Delivery method     在做订单的时候,选择相应的运输方法, 系统 ...

  9. GIS+=地理信息+行业+大数据——纽约公开11亿条出租车和Uber原始数据下载及分析

    一览众山小编辑团队 原文/ Todd Schneider 翻译/ 沈玮薇 陈翚 文献/ 蒋理 校核/ 众山小编辑/ 众山小 排版/ 徐颖 2014-2015 © 转载请注明:源自公众号"一览 ...

  10. 用字符串处理函数中的比较函数strcmp做的一个密码登录验证

    正确返回0 1大返回正数 2大返回负数  1,2表示输入字符串1和字符串2 根据ASCII码大小来判断 代码: #include<stdio.h> #include<string.h ...