精华内容
下载资源
问答
  • 1、定义 路由:指根据url定位到具体的类或者函数的程序,本质...2、路由传参 2.1 动态传参 # 动态传参语法 @app.route(路径+/<参数名>/') #例子 @app.route('/index/<id>/') def index(id) print(id) ...

    一、注册路由

    1、定义

    路由:指根据url定位到具体的类或者函数的程序,本质就是建立url跟程序之间的映射。flask中使用的路由被称之为注册路由

    2、路由传参

    2.1 动态传参

    # 动态传参语法
    @app.route(路径+/<参数名>/')
    #例子
    @app.route('/index/<id>/')
    def index(id)
        print(id)
        return id
    

    使用转换器进行对传参的类型进行限定

    string默认的数据类型,接收没有任何斜杆\ /的字符串
    int整型
    float浮点型
    path跟string类型类似,它可以接受斜杆/\
    uuiduuid格式的字符串
    any可以指定多种路径
    #使用方法
    @app.route('/index/<int:id>/')
    def index(id):
        return id
    
    # any类型的用法、它可以指定多种路径
    @app.route('/<any(user,admin):who>/<id>/')
    def home(who,id):
        if who== 'user':
            return '这里是普通用户{}的主页'.format(id)
        else:
            return '这里是管理员{}的主页'.format(id)    
    

    动态路由一般可以用来提高网站的曝光率

    2.2 查询字符串传参(也就是?传参)

    注意:request.args获取的是解析后的字典类型,request.query_string获取的是问号后的原生字符串。

    http://127.0.0.1:5000/?name='hello'&age=18
    @app.route('/')
    def home():
        print(request.args)
        #>: ImmutableMultiDict([('name', "'hello'"), ('age', '18')])
        print(request.query_string)
        #>: b'name=%27hello%27&age=18'
        return '这是跟路径'
    

    3、自定义动态路由过滤(转换器)

    3.1 正则匹配

    from flask import Flask, views, url_for
    from werkzeug.routing import BaseConverter
    
    app = Flask(__name__)
    
    class RegexConverter(BaseConverter):
        """
        自定义URL匹配正则表达式
        """
        def __init__(self, map, regex):
            super(RegexConverter, self).__init__(map)
            self.regex = regex
    
        def to_python(self, value):
            """
            路由匹配时,匹配成功后传递给视图函数中参数的值
            """
            return int(value)
    
        def to_url(self, value):
            """
            使用url_for反向生成URL时,传递的参数经过该方法处理,返回的值用于生成URL中的参数
            """
            val = super(RegexConverter, self).to_url(value)
            return val
    # 添加到flask中
    app.url_map.converters['regex'] = RegexConverter
    # 在路由中使用
    @app.route('/index/<regex("\d+"):nid>')
    def index(nid):
        print(url_for('index', nid='888'))
        return 'Index'
    
    if __name__ == '__main__':
        app.run()
    

    注意:必须继承werkzeug.routing 的BaseConverter类,regex属性指定路由过滤规则,app.url_map.converters本质就是一个字典

    3.2 自定义动态路由过滤器处理动态路由

    # -*-coding:utf-8 -*-
    from flask import Flask,url_for
    from werkzeug.routing import BaseConverter
    
    app = Flask(__name__)
    
    class ListConverter(BaseConverter):
        regex = '.*'
        def to_python(self, value):
            '''
            对动态参数进行处理
            :param value: 路由里的动态参数
            :return: 处理好的动态参数结果
            '''
            print(value) # a+b+c
            return value.split('+')
        def to_url(self, value):
            '''
            搭配url_for使用,对value进行处理
            :param value: url_for指定的动态参数
            :return:
            '''
            print('to_url:',value) #结果:to_url: ['a', 'b']
            return '+'.join(value)
    
    app.url_map.converters['list']=ListConverter
    
    @app.route('/test/<list:ids>/') #注意这里没有设置endpoint,所以默认是home
    def home(ids):
        # 对http://127.0.0.1:5000/test/a+b+c/发起请求
        print('home:',ids) # 结果 ['a', 'b', 'c']
        print(url_for('home',ids=['a','b'])) #结果 /test/a+b/
        return 'home'
    
    if __name__ == "__main__":
        app.run(debug=True)
    

    总结:to_python()方法是对动态路由的参数进行处理,to_url是对url_for()函数传入的动态参数进行处理

    4、endpoint参数

    4.1 endpoint 简介

    endpoint是注册路由中的一个参数,也叫端点(类似函数的别名)通过url_for函数+endpoint参数值,可以反解出url

    @app.route('/index11',endpoint='i')
    def index():
        print(url_for('i')) #打印结果:/index11
    

    4.2、对endpoint参数有关源码分析

    def route(self, rule, **options):
        def decorator(f):
            # 1、先从options中获取endpoint值,如果没有,则赋值None给endpoint
            endpoint = options.pop("endpoint", None)
            # 2、将endpoint传到add_url_rule函数(也是注册路由的关键函数)中处理
            self.add_url_rule(rule, endpoint, f, **options)
            return f
    
        return decorator
    def add_url_rule(self,rule,endpoint=None,view_func=None,
        provide_automatic_options=None,
        **options
        ):
        # 3、先判断endpoint是否为None  
        if endpoint is None:
            # 4、endpoint值为None的时候,调用_endpoint_from_view_func   
            endpoint = _endpoint_from_view_func(view_func)
        #4/7、 endpoint有值的时候,把它传给options    
        options["endpoint"] = endpoint
    def _endpoint_from_view_func(view_func):
        # 5、用断言来判断函数是否为None,是则报错
        assert view_func is not None, "expected view func if endpoint is not provided."
        # 6、返回一个函数的的函数名
        return view_func.__name__
    

     5、add_url_rule(): 注册路由的第二种方式

    def index():
        return '注册路由的另一种方式'
    
    app.add_url_rule('/index/',endpoint('自定义名字'),view_func=index(函数地址)
    

    6、注册路由中用到的参数

    # ----------常用参数--------------
    # @app.route()和app.add_url_rule参数
    rule      #路由路径
    view_func # 视图函数名称
    endpoint  # 端点名字,用于url_for反向解析url
    methods   # 允许请求的方式
    
    # -----------其他参数---------------
    # 1、对url是否加/是否有严格要求 
    strict_slashes=Flase  #访问http://127.0.0.1/index和http://127.0.0.1/index/都可以
    @app.route('/index', strict_slashes=True)  #仅可以访问http://www.xx.com/index
    
    # 2、重定向 redirect_to
    @app.route("/index",redirect_to='/home/') #当你访问index页面的时候,会跳到home页面去
    
    # 3、为函数提供默认参数值
    defaults = None #默认值, 当URL中无参数,函数需要参数时,使用defaults = {'k': 'v'}
    @app.route('/home',defaults={'k':'v'})
    def home(k):
        print(k) # v
    # 4、设置子域名 subdomain
    from flask import Flask,url_for
    
    app = Flask(__name__)
    app.debug = True
    '''
    先在hosts设置域名解析(就是在本机的hosts文件上编辑上域名对应ip的关系) 
    域名解析会先解析本地如果没有再解析dns服务器
    C:\Windows\System32\drivers\etc\hosts
    
    127.0.0.1 mark.com
    127.0.0.1 admin.mark.com
    
    '''
    app.config['SERVER_NAME'] = 'mark.com:5000' # 这个代表访问这个域名的时候要访问5000端口
    
    @app.route("/")
    def index():
        return '设置域名成功'
    
    @app.route("/admin_demo/",subdomain='admin')
    def admin_demo():
    
        return '设置子域名成功'
    
    '''
    在浏览器中访问主域名
    mark.com:5000/
    在浏览器中访问子域名
    admin.mark.com:5000/admin_demo/
    
    注意:后面跟的path路径部分正常写
    '''
    if __name__ == '__main__':
        app.run(host='127.0.0.1',port=5000) # 测试服务器不稳定,尽量手动制定ip和端口
    

    二、视图

    1、视图函数

    视图函数跟django的视图函数类似,只不过在视图函数中加装饰器有点不一样,flask中需要将装饰器卸载注册路由下面,视图函数上面,同时,装饰器内部要使用@wraps(func)方法,用于保护被装饰函数的属性

    from flask import Flask, request
    from functools import  wraps
    
    app = Flask(__name__)
    
    def login_verify(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            user_name = request.args.get('user')
            password = request.args.get('password')
            if user_name == 'mark' and password == '123':
                return func(*args,**kwargs)
            else:
                return '请登录'
        return wrapper
    
    @app.route('/my_info/')
    @login_verify
    def my_info():
        return '个人信息页面'
    

    2、视图类

    2.1 标准类视图类

    '''
    1、继承flask.views.View
    2、注册路由:app.add_url_rule(rule,endpoint,view_func)
    --rule:路由地址
    --endpoint: 端点
    --view_func: 函数名称(不用加括号)
    3、重写dispatch_request方法
    '''
    # -*-coding:utf-8 -*-
    from flask import Flask,views,url_for
    
    app=Flask(__name__)
    
    class S_Test(views.View):
        def dispatch_request(self):
            print(url_for('List')) #/stest
            return '这是标准视图类'
    '''
    注意:如果设置了endpoint,那么使用url_for反转的时候,就要用endpoint的值
         如果没有,则可以直接用as_view中的指定的视图名字来作为反转
         as_view('视图名字')
    '''
    app.add_url_rule('/stest',view_func=S_Test.as_view('List'))
    if __name__=='__main__':
        app.run(debug=True)
    

    2.2 基于调度方法的视图类

    '''
    1、继承flask.views.MethodView
    2、指定支持请求类型 methods=[]
    3、指定使用哪些装饰器 decorators = []
    4、写相应的请求函数
    5、注册路由
    '''
    from flask import Flask,views,url_for
    from functools import wraps
    
    app=Flask(__name__)
    
    class Test(views.MethodView):
        methods = ['GET',"POST"]  #设置可以接收的请求方法
        decorators = [auth]  # 指定装饰器,注意不能添加单引号或者双引号
        # get请求方法
        def get(self):
            return '这是get请求方法'
        # post请求方法
        def post(self):
            return '这是post请求方法'
    # 同样,如果没有指定endpoint,url_for反转的时候,同样是使用as_view中的name值
    app.add_url_rule('/test',view_func=Test.as_view(name='test1'))
    if __name__=='__main__':
        app.run(debug=True)
    

    三、模板引擎

    1、概述

    模版引擎:指实现视图的业务逻辑和返回给前端的页面逻辑分离的工具。

    作用:实现业务逻辑和页面逻辑的分离,实现动态的去渲染页面

    模版路径配置,可以在Flask类的template_folder参数设置

    app = Flask(__name__,template_folder='模板位置')
    
    app =Flask(__name__)
    app.template_folder='模版位置'
    

    2、模版传参

    # 第一种,在render_template中把参数传过去
    @app.route('/')
    def index():
        return render_template('index.html',name='hello',age=18)
    
    # 第二种,把参数放在字典中,将字典传递过去
    @app.route('/')
    def index():
        context_dict={
            'name':'hello',
            'age':18
        }
        return render_template('index.html',context=context_dict)
    # 第三种,将字典打散传递过去
    return render_template('index.html',**context_dict)
    
    # ------------前端对接收到参数的处理--------------------
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        # 参数关键词
        {{ name }}
        # 字典参数
        {{ context.name }}
        {{ context.get('age') }}
        {{context['name']}}
    </body>
    </html>
    

    3、模板引擎使用url_for

    注意:url_for在模板中用法跟在视图函数的用法一样,没有指定endpoint,就使用函数名,指定了,就使用endpoint的值进行反转

    # 例子
    @app.route('/index')
    def index():
        return render_template('index.html')
    @app.route('/home',endpoint='h')
    def home():
        return render_template('index.html')
    
    # html文件
    <a href="{{ url_for('h') }}">home</a>
    <a href="{{ url_for('index') }}">index</a>
    #这句会报错,因为home函数的路由已经设置了endpoint
    <a href="{{ url_for('home') }}">home1</a> 
    

    4、jinja2控制语句使用

    # 控制语句都是以{% ... %} 开始 ,以{ %end...% }结束
    

    4.1 逻辑语句和if 语句

    '''
    判断: >、<、<=、==、!=
    逻辑:and、or、not、()
    '''
    { % if age>18 %}
        ...
    {% elif age ==9 %}
        ...
    {% else %}
        ...
    {%endif %} #表示结束判读
    

    4.2 循环语句和for循环

    # 遍历列表,可迭代对象,字典等
    {% for dict in d %}
         ...
    {% else %}
         ... # 遍历没有内容,才会执行else,for else逻辑在python是没有的
    {% endfor %}
    # 反转遍历
    {% for dict in d | reverse %}
    #------------ for 常用循环变量--------------
    loop.index     #当前循环的索引(从1开始)
    loop.index()   #当前循环的索引(从0开始)
    loop.first       #是否是第一次循环,是返回True,否则返回Flase
    loop.last       #是否是最后一次循环,是返回True,否则返回Flase
    loop.length    #总共可以循环的次数 / 迭代器的长度
    
    # 例子
     {% for college in colleges %}
          {% if loop.first %}
    <tr style="background: blue">
    {% elif loop.last %} <tr style="background: yellow "> {% else %} <tr> {% endif %} <td>{{ loop.index }}</td> <td>{{ loop.index0 }}</td> <td>{{ college.name }}</td> <td>{{ loop.length }}</td> </tr> {% endfor %}

    5、静态文件在模板中的使用

    {{ url_for('static',filename='相对于static文件夹的路径') }}
    
    <!DOCTYPE html>
    <html lang="en">
    <head>
     ...
        <script src="{{ url_for('static',filename='js/demo.js') }}"></script>    
    </head>
    ....
    

    6、模板继承

    定义一个基模版,在基模版中定义一些block块,以便给子模版实现自己的功能

    # 1、基模版parent.html
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    # top是自己定义的变量名
    {% block top %}
       <p>我是父模版</p>
    {% endblock %}
    </body>
    </html>
    # 2、子模板son.html继承parent.html
    {% extends 'parent.html' %}
    {% block top %}
        {{ super() }}  #表示继承父模板中的本块的代码
    <p>我继承了parent模版</p>
    {% endblock %}
    

    四、闪现

    1 定义

    闪现:flask提供的一个简单的方法,用来向用户反馈信息,本质是将信息放在session中,必须设置secret_key,下次请求的时候,再从session中获取。

    注意:闪现有效期只有一次,当下一次请求获取闪现的信息后,它就失效了

    2 用法

    from flask import Flask,flash,make_response,get_flashed_messages
    # 需要导入flash、get_flashed_messages 用来设置和获取闪现值
    app=Flask(__name__)
    app.secret_key='shanxian'
    
    @app.route('/')
    def home():
        flash('欢迎来到首页')  #设置闪现值
        return 'index'
    
    @app.route('/index')
    def index():
        a=get_flashed_messages() #获取闪现值
        return 'index11'
    

    前端获取闪现信息

    {% with messages= get_flashed_messages() %} # 获取所有闪现信息,返回的是列表
        {% for m in messages %}
        <li>{{ m }}</li>
        {% endfor %}
    {% endwith %}
    

    3 分类闪现

    默认分类是:message

    #1、设置:
    flash('hello',category='test') 
    # 或
    flash('hello','test')
    # 2、取值,获取所有闪现信息的类别和内容
    res=get_flashed_messages(with_categories=True)
    
    # ------------前端获取(注意with_categories=true别忘记设置)---------------
    {% with messages= get_flashed_messages(with_categories=true) %} # 获取所有闪现信息,返回的是列表
        {% for c,m in messages %}
        <li>{{ m }},{{ c }}</li>
        {% endfor %}
        {{ messages }}
        {% endwith %}
    ''' 结果如下:c是分类,m是闪现信息
    test111,error
    test222,tes
    test333,test3
    [('message', '欢迎来到首页'), ('error', 'test111'), ('tes', 'test222'), ('test3', 'test333')]
    '''
    

    4 过滤闪现信息( category_filter参数)

    #-----------后端视图函数过滤-----------------
    #默认category_filter =message
    get_flashed_messages(category_filter=['类名'])
    
    # -----------前端过滤闪现信息--------------
    {% with messages= get_flashed_messages(category_filter=['test']) %} # 获取test类的闪现信息,返回的是列表
        {% for m in messages %}
        <li>{{ m }}</li>
        {% endfor %}
    
    {% endwith %}
    
    展开全文
  • 动态页面的开发,基本会涉及一个比较关键的问题,那就是传参。后台把不同的参数传递给前台,前台页面根据不同的参数显示不同的页面效果,这叫做渲染。 不同的后台开发环境均有不同的渲染方式,Node开发过程中,传递...

    动态页面的开发,基本会涉及一个比较关键的问题,那就是传参。后台把不同的参数传递给前台,前台页面根据不同的参数显示不同的页面效果,这叫做渲染。

    不同的后台开发环境均有不同的渲染方式,Node开发过程中,传递参数的方式非常简单直观。直接就是渲染模版即可,如下代码:

    res.render('error', {
      message: err.message,
      error: err
    });

    渲染页面模版error,给它传递了2个参数。这样前台页面模版就可以使用这两个参数了。如下error页面代码:

    <h1><%= message %></h1>
    <h2><%= error.status %></h2>
    <pre><%= error.stack %></pre>

    当然页面上不仅仅只可以使用render方法传递的那几个参数,如果你使用的是express框架的话,你还可以通过app.locals以及res.locals对象赋值的方式传递其他的参数到页面模版引擎。例如:

    router.use(function (req, res, next) {
      res.locals.period = moment().day(5).format('YYYYMMDD');  // 得到本周五的日期
      res.locals.prePeriod = moment().day(5 - 7).format('YYYYMMDD'); // 得到上周五的日期
    });

    这个路由方法,会将period以及prePeriod两个变量传递到该路由下所有路径的模版引擎上。在该路由下的所有页面模版上均可以使用这两个变量。

    但是,存在另外一种情况,页面跳转的时候,参数该什么传递呢?

    页面的跳转,例如:res.redirect('/login'),这条语句是把请求跳转到另外一个路径上;或者,res.redirect('back')返回上一页。页面的跳转相当于重新访问一遍目标路径的路由。这种情况下,我们想传递参数,通过redirect方法貌似不可以实现。可能有人会想到使用session对象来作为一个中介进行传参,参数展现后就自动删除该条session,没错,这就是connect-flash模版所实现的功能。

    具体可参考:

    1. Express框架之connect-flash详解 - 高山上的鱼 - 博客频道 - CSDN.NET

    2. connect-flash 用法详解 - 云库网

    原理和使用方法都已经有了,我就不赘述了,我的使用场景一般都是当进入一个没有权限访问的页面时,跳转到登陆界面所提示信息的展现。好多场景其实是可以通过前台Ajax来取代的,例如:登陆界面的验证等等。

    总结

    Node Web开发中,后台三种传参渲染页面的方式:

    1. 普通页面渲染使用res.render()方法;

    2. 还有别忘了express提供的app.locals以及res.locals对象;

    3. 针对跳转页面的场景可以尝试使用connect-flash模块;


    更多内容请访问:LP's Blog

    展开全文
  • Ionic4使用angualr 路由

    千次阅读 2019-03-07 16:22:38
    1.关于angular 路由 首先angular 路由分为两种 ①.普通版路由 ②.懒加载路由 路由详细请看https://www.angular.cn/guide/router 2.那如何在ionic 中使用angular 路由路由又如何设计。 首先 我们创建 ,...

     

    1.关于angular 路由

        首先angular 路由分为两种 

        ①.普通版路由

        ②.懒加载路由

        路由详细请看https://www.angular.cn/guide/router

    2.那如何在ionic 中使用angular 路由。路由又如何设计。

       首先 我们创建 ,根路由模块 app-routing.module

       app-routing.module.ts代码:

    import { NgModule } from '@angular/core';
    import { PreloadAllModules, RouterModule, Routes } from '@angular/router';
    import {HashLocationStrategy, LocationStrategy} from '@angular/common';
    
    const routes: Routes = [
      { path: '', loadChildren: './tabs/tabs.module#TabsPageModule' },
      { path: 'smart-clinic', loadChildren: './smart-clinic/smart-clinic.module#SmartClinicPageModule' },
      { path: 'information', loadChildren: './information/information.module#InformationPageModule' },
      { path: 'member-centre', loadChildren: './member-centre/member-centre.module#MemberCentrePageModule' },
      { path: 'login', loadChildren: './login/login.module#LoginPageModule' },
    ];
    @NgModule({
      imports: [
        RouterModule.forRoot(routes, {preloadingStrategy: PreloadAllModules})
      ],
      exports: [RouterModule],
      providers: [
        {provide: LocationStrategy, useClass: HashLocationStrategy}
      ],
    })
    export class AppRoutingModule {}
    

       将 tabs 设成空值。默认时 将路由到 tabs

      app.module代码:

    import { NgModule } from '@angular/core';
    import { BrowserModule } from '@angular/platform-browser';
    import { RouteReuseStrategy } from '@angular/router';
    
    import { IonicModule, IonicRouteStrategy } from '@ionic/angular';
    import { SplashScreen } from '@ionic-native/splash-screen/ngx';
    import { StatusBar } from '@ionic-native/status-bar/ngx';
    
    import { AppRoutingModule } from './app-routing.module';
    import { AppComponent } from './app.component';
    import {TabsService} from './core/tabs.service';
    @NgModule({
      declarations: [AppComponent],
      entryComponents: [],
      imports: [ BrowserModule, IonicModule.forRoot({
          backButtonText: '',
          hardwareBackButton: true,
          mode: 'ios',
          backButtonIcon: 'ios-arrow-back',
      }), AppRoutingModule],
      providers: [
        StatusBar,
        SplashScreen,
        TabsService,
        { provide: RouteReuseStrategy, useClass: IonicRouteStrategy }
      ],
      bootstrap: [AppComponent]
    })
    export class AppModule {}
    

       AppRoutingModule(路由根路由模块)导入到app.module中

       

    同理 我们来配置 tabs 的路由

    tabs.router.module代码:

    import { NgModule } from '@angular/core';
    import { RouterModule, Routes } from '@angular/router';
    import { TabsPage } from './tabs.page';
    
    const routes: Routes = [
      {
        path: 'tabs',
        component: TabsPage,
        children: [
            {path: 'home', children: [{path: '', loadChildren: '../home/home.module#HomePageModule'}]},
            {path: 'smart-clinic', children: [{path: '', loadChildren: '../smart-clinic/smart-clinic.module#SmartClinicPageModule'}]
       },
       {
        path: 'information',
        children: [
              {path: '', loadChildren: '../information/information.module#InformationPageModule'}
            ]
       },
       {
        path: 'member-centre',
        children: [
              {path: '', loadChildren: '../member-centre/member-centre.module#MemberCentrePageModule'}
            ]
          },
          {
            path: '',
            redirectTo: '/tabs/home',
            pathMatch: 'full'
          }
        ]
      },
      {
        path: '',
        redirectTo: '/tabs/home',
        pathMatch: 'full'
      }
    ];
    
    @NgModule({
      imports: [
        RouterModule.forChild(routes)
      ],
      exports: [RouterModule]
    })
    export class TabsPageRoutingModule {}
    
    <ion-tabs >
      <ion-tab-bar >
        <ion-tab-button tab="home" >
          <ion-icon name="flash"></ion-icon>
          <ion-label>在线问诊</ion-label>
        </ion-tab-button>
    
        <ion-tab-button tab="smart-clinic">
          <ion-icon name="flash"></ion-icon>
          <ion-label>智能门诊</ion-label>
        </ion-tab-button>
    
        <ion-tab-button tab="information">
          <ion-icon name="apps"></ion-icon>
          <ion-label>资讯信息</ion-label>
        </ion-tab-button>
    
        <ion-tab-button tab="member-centre">
          <ion-icon name="send"></ion-icon>
          <ion-label>会员中心</ion-label>
        </ion-tab-button>
      </ion-tab-bar>
    
    </ion-tabs>

    同理 TabsPageRoutingModule需要导入 到tabs.module

    import { IonicModule } from '@ionic/angular';
    import { NgModule } from '@angular/core';
    import { CommonModule } from '@angular/common';
    import { FormsModule } from '@angular/forms';
    
    import { TabsPageRoutingModule } from './tabs.router.module';
    
    import { TabsPage } from './tabs.page';
    
    @NgModule({
      imports: [
        IonicModule,
        CommonModule,
        FormsModule,
        TabsPageRoutingModule
      ],
      declarations: [TabsPage]
    })
    export class TabsPageModule {}
    

      设置full时、我们默认访问tabs/home。如图

     

    到了关键 时刻 怎么路由到子页面。这是ionic团队 对 angular 路由封装。具体看ionic 团队的文档

    home.page.ts:

    import {Component, OnInit} from '@angular/core';
    import {NavController} from '@ionic/angular';
    
    @Component({
      selector: 'app-home',
      templateUrl: 'home.page.html',
      styleUrls: ['home.page.scss'],
    })
    export class HomePage implements OnInit {
        slideOpts = {
            init: 'true',
            effect: 'flip',
            initialSlide: '1'
        };
        constructor(private nav: NavController) { }
    
        ngOnInit() {
         }
        goOverview() {
            this.nav.navigateForward('/tabs/home/clinics-list/clinic-overview');
        }
        goSearch() {
            this.nav.navigateForward('/tabs/home/search-for');
        }
        goList() {
            console.log('导航到list页');
            this.nav.navigateForward('/tabs/home/clinics-list', { queryParams: {
                page: '测试传参'
            }});
        }
    }
    

    home.module.ts

    import {NgModule} from '@angular/core';
    import {CommonModule} from '@angular/common';
    import {IonicModule} from '@ionic/angular';
    import {FormsModule} from '@angular/forms';
    import {RouterModule} from '@angular/router';
    
    import {HomePage} from './home.page';
    
    
    @NgModule({
        imports: [
            CommonModule,
            FormsModule,
            IonicModule,
            RouterModule.forChild([
                {path: '', component: HomePage},
                {path: 'position', loadChildren: './position/position.module#PositionPageModule'},
                {path: 'clinics-list', loadChildren: './clinics-list/clinics-list.module#ClinicsListPageModule'},
                {path: 'search-for', loadChildren: './search-for/search-for.module#SearchForPageModule'},
            ])
        ],
        declarations: [HomePage]
    })
    export class HomePageModule {
    }
    

    页面写一个click事件调用goOverview这个事件就可以跳转到 指定页面。

     

    这是ionic团队对angular 路由的简单封装, 路由的文档。

    import { Location } from '@angular/common';
    import { NavigationExtras, Router, UrlTree } from '@angular/router';
    import { RouterDirection } from '@ionic/core';
    import { IonRouterOutlet } from '../directives/navigation/ion-router-outlet';
    import { Platform } from './platform';
    export interface AnimationOptions {
        animated?: boolean;
        animationDirection?: 'forward' | 'back';
    }
    export interface NavigationOptions extends NavigationExtras, AnimationOptions {
    }
    export declare class NavController {
        private location;
        private router?;
        private topOutlet?;
        private direction;
        private animated?;
        private guessDirection;
        private guessAnimation?;
        private lastNavId;
        constructor(platform: Platform, location: Location, router?: Router | undefined);
        /**
         * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
         * it's equivalent to call `this.router.navigateByUrl()`, but it's explicit about the **direction** of the transition.
         *
         * Going **forward** means that a new page it's going to be pushed to the stack of the outlet (ion-router-outlet),
         * and that it will show a "forward" animation by default.
         *
         * Navigating forward can also be trigger in a declarative manner by using the `[routerDirection]` directive:
         *
         * ```html
         * <a routerLink="/path/to/page" routerDirection="forward">Link</a>
         * ```
         */
        navigateForward(url: string | UrlTree | any[], options?: NavigationOptions): Promise<boolean>;
        /**
         * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
         * it's equivalent to call:
         *
         * ```ts
         * this.navController.setDirection('back');
         * this.router.navigateByUrl(path);
         * ```
         *
         * Going **back** means that all the pages in the stack until the navigated page is found will be pop,
         * and that it will show a "back" animation by default.
         *
         * Navigating back can also be trigger in a declarative manner by using the `[routerDirection]` directive:
         *
         * ```html
         * <a routerLink="/path/to/page" routerDirection="back">Link</a>
         * ```
         */
        navigateBack(url: string | UrlTree | any[], options?: NavigationOptions): Promise<boolean>;
        /**
         * This method uses Angular's [Router](https://angular.io/api/router/Router) under the hood,
         * it's equivalent to call:
         *
         * ```ts
         * this.navController.setDirection('root');
         * this.router.navigateByUrl(path);
         * ```
         *
         * Going **root** means that all existing pages in the stack will be removed,
         * and the navigated page will become the single page in the stack.
         *
         * Navigating root can also be trigger in a declarative manner by using the `[routerDirection]` directive:
         *
         * ```html
         * <a routerLink="/path/to/page" routerDirection="root">Link</a>
         * ```
         */
        navigateRoot(url: string | UrlTree | any[], options?: NavigationOptions): Promise<boolean>;
        /**
         * Same as [Location](https://angular.io/api/common/Location)'s back() method.
         * It will use the standard `window.history.back()` under the hood, but featuring a `back` animation.
         */
        back(options?: AnimationOptions): void;
        /**
         * This methods goes back in the context of ionic's stack navigation.
         *
         * It recursivelly finds the top active `ion-router-outlet` and calls `pop()`.
         * This is the recommended way to go back when you are using `ion-router-outlet`.
         */
        pop(): Promise<void>;
        /**
         * This methods specifies the direction of the next navigation performed by the angular router.
         *
         * `setDirection()` does not trigger any transition, it just sets a set of flags to be consumed by `ion-router-outlet`.
         *
         * It's recommended to use `navigateForward()`, `navigateBack()` and `navigateBack()` instead of `setDirection()`.
         */
        setDirection(direction: RouterDirection, animated?: boolean, animationDirection?: 'forward' | 'back'): void;
        /**
         * @internal
         */
        setTopOutlet(outlet: IonRouterOutlet): void;
        /**
         * @internal
         */
        consumeTransition(): {
            direction: RouterDirection;
            animation: "forward" | "back" | undefined;
        };
        private navigate;
    }
    

    如果有疑问请加:

    qq群:390736068

    展开全文
  • flask路由的各种定义方式

    千次阅读 2018-06-01 17:34:37
    路由的各种定义方式 请求方式限定 使用 methods 参数指定可接受的请求方式,可以是多种 @app.route('/',methods=['GET']) def hello(): return '<h1>hello world</h1>' 路由查找方式 同一路由...

    路由的各种定义方式

    请求方式限定

    使用 methods 参数指定可接受的请求方式,可以是多种

    @app.route('/',methods=['GET'])
    def hello():
        return '<h1>hello world</h1>'
    

    路由查找方式

    同一路由指向两个不同的函数,在匹配过程中,至上而下依次匹配

    
    @app.route('/')
    def hello():
        return '<h1>hello world</h1>'
    
    @app.route('/')
    def hello_2017():
        return '<h1>hello 2017</h1>'
    

    所以上面路由 / 输出的结果为 hello 函数的结果

    给路由传参示例

    有时我们需要将同一类URL映射到同一个视图函数处理,比如:使用同一个视图函数 来显示不同用户的个人信息。

    路由传递的参数默认当做string处理,这里指定int,尖括号中的内容是动态的,也可不指定类型

    @app.route('/user/<int:id>')
    def hello_itheima(id):
        return 'hello itcast %d' %id

    重定向redirect示例

    from flask import redirect
    @app.route('/')
    def hello_itheima():
        return redirect('http://www.itcast.cn')

    返回JSON

    from flask import Flask,json
    @app.route('/json')
    def do_json():
        hello = {"name":"stranger", "say":"hello"}
        return json.dumps(hello)
    

    返回状态码示例

    在 Python 中返回状态码有两种方式实现:

    - 直接return 
        - 可以自定义返回状态码,可以实现不符合http协议的状态码,例如:error=666,errmsg='查询数据库异常',其作用是为了实现前后端数据交互的方便
    - abort方法
        - 只会抛出符合http协议的异常状态码,用于手动抛出异常
    
    @app.route('/')
    def hello_itheima():
        return 'hello itcast',666

    正则路由示例

    在web开发中,可能会出现限制用户访问规则的场景,那么这个时候就需要用到正则匹配,限制访问,优化访问

    • 导入转换器包
    from werkzeug.routing import BaseConverter
    
    • 自定义转换器并实现
    # 自定义转换器
    class Regex_url(BaseConverter):
        def __init__(self,url_map,*args):
            super(Regex_url,self).__init__(url_map)
            self.regex = args[0]
    
    app = Flask(__name__)
    # 将自定义转换器类添加到转换器字典中
    app.url_map.converters['re'] = Regex_url
    
    @app.route('/user/<re("[a-z]{3}"):id>')
    def hello_itheima(id):
        return 'hello %s' %id
    

    自带几种转换器

    DEFAULT_CONVERTERS = {
        'default':          UnicodeConverter,
        'string':           UnicodeConverter,
        'any':              AnyConverter,
        'path':             PathConverter,
        'int':              IntegerConverter,
        'float':            FloatConverter,
        'uuid':             UUIDConverter,
    }
    
    

    联系方式

    QQ:1217675462
    欢迎交流

     
    展开全文
  • 开始flash项目

    2019-04-18 20:40:35
    1、url路由传递参数 ​ from flask import Flask app = Flask(__name__) @app.route('/say_hi/<name>') #需要在url传参的话用<>括起来 def say_hi(name): #然后通过函数设置参数 return 'hi %s' % ...
  • orm之路由

    2018-11-19 13:18:00
    进行分组,这是无名分组,分组后会按位置进行传参,传到视图函数views.flash里 ] View Code 3.反向解析 先在路由层urls命一个名  1)无参数:url(r"^/publish/",views.publish,name='ddd')  2)无名...
  • 前两天参加阿里云7天培训,用python+Flask写了...那么怎么在不同的路由之间去传递参数呢? 我想到是设置的全局变量去解决这个问题,上代码 FrontResult={}#定义的全局变量字典 @app.route('/add',methods=['POST','GET.
  • B、通过链接传递参数,在本章的例子中,routes.rb文件中定义的路由需要改成 post 'posts/create_comment/:post_id' => 'posts#create_comment' ,然后form_for后面的链接也需要给链接加上参数 ,url: "/posts/create_...
  • flask-(Forms表单与flash消息闪现)

    千次阅读 2018-08-21 10:57:19
     (1)前端正常写,通过路由传参  (2)后端获取数据方式  ① get请求:request.args.get()  ② post请求:request.form.get() 3.flash消息闪现,提示信息,此处列举两处 (1)python代码  ① flash('...
  • 2019前端面试常问

    2019-08-07 18:11:13
    面试项目简介: Vue:hash(散列算法)DOM Diff算法(React) ...路由传参: https://www.jianshu.com/p/4debd60d3187#!/xh 一、直接在路由中写参数 二、通过prams传参 三、通过query传参 Vue数据双向绑定: https://...
  • Python Flash(2)

    千次阅读 2019-07-30 14:12:17
    1.路由需要设置get和post两种请求-->需要判断请求方式 2.获取请求参数 3.密码和重复输入的密码是否相同 4.如果没问题,返回success """ @app.route('/', methods=['GET', 'POST']) def index(): # request : 请求...
  • 一、路由系统 1. 示例 from flask import Flask,render_template,request,redirect,session,url_for app = Flask(__name__) # endpoint别名,通过别名可反向生成url # url后跟参数规则/index/<int:...
  • Flask WEB之表单提交

    2020-02-12 14:08:06
    1. 变量 1.1路由变量 @app.route('/<str: name>', methods=['GET','POST']) ... 路由传参共有三种数据类型:int,float,str. 默认情况下为str类型 在<>中配置。 """ return 'your name is: % s' ...
  • (1)前端正常写,通过路由传参 (2)后端获取数据方式 ① get请求:request.args.get() ② post请求:request.form.get() 3.flash消息闪现,提示信息,此处列举两处 (1)python代码 ① flash...
  • 路由器属于OSI第三层即网络层设备,它根据IP地址进行寻址,通过路由表路由协议产生。交换机最大的好处是快速,路由器最大的好处是控制能力强。   14.多进程与多线程,并发与并行 以后整理 ...
  • 路由传参 @app.route('/user/<username>') #常用的 不加参数的时候默认是字符串形式的 @app.route('/post/<int:post_id>') #常用的 #指定int,说明是整型的 @app.route('/post/<float:post_id>') @app.route('...
  • Python编程:Flask入门到精通

    千次阅读 2019-01-30 16:37:37
    路由分发 -&gt; 执行视图函数 -&gt; 响应报文 -&gt; HTTP响应 -&gt; 浏览器 前端和后端 前端: -浏览器 -手机app -爬虫 -程序urllib urllib2 ajax 后端: 服务器 + WSGI + web框架程...
  • flask知识点

    2019-04-24 20:26:00
    ')动态路由,通过函数传参jsonify() 转换成页面能看懂得json字符串redirct('') 跳转路由地址redirct(url_for(函数名)) 跳转函数名abort(404) 抛出异常'{}'.format(函数) 格式化格式 动态传参 ma...
  • 2016年前端技术观察

    千次阅读 2016-12-14 14:58:31
    我用过JavaScript、AS、PHP、Java、Ruby和Python语言,也用过HTML、Flash、Flex、wxPython、Canvas2d和WebGL界面开发,还用过SSH、ROR、Django的服务端开发,所以当服务端同学在聊不同语言时,我一点也不羡慕,别...
  • 文章目录0x01路由0x02 模版和静态文件2.1 文件结构2.2代码2.3 运行效果0x03 json3.1运行效果0x04 重定向4.1 访问跳转4.2 打印路由4.3 跳转传参0x05 jinjia2模版5.1代码5.2 运行效果0x06 蓝图6.1代码结构6.2 代码0x07...
  • Flask 知识点

    2019-06-04 11:56:00
    Flask 知识点 flask知识点 ...app.config['JSON_AS_ASCII'] = False #中文转换...')动态路由,通过函数传参jsonify() 转换成页面能看懂得json字符串redirct('') 跳转路由地址redirct(url_for(函数名)) 跳...
  • ajax

    2019-11-20 19:04:39
    AJAX5步法 1、创建异步对象XMLHttpRequest 2、设置回调函数 3、open()方法连接服务器 4、send()方法发送数据至服务器 5、回调函数中针对不同响应状态...get请求类型传值方式是将数据拼接到路由后进行传值,所以...
  • AJAX封装+跨域(jsonp)

    2019-11-20 19:28:13
    AJAX的调用还十分麻烦,...封装:基本模板与传参 此时调用模板时,如下所示 封装1:建立异步对象 封装2:判断请求类型 get请求类型传值方式是将数据拼接到路由后进行传值,所以接下来需要判断是否传值(对比po...
  • 路由 Route route文件中的先后顺序代表了路由生效的先后顺序 /user 匹配 /user 但不匹配 /user/ 可以用404做路由 GET /ignore 404 根据某些参数更具体的路由 public static void page(String id) { Page page = ...
  • Flask总结

    2018-08-24 10:09:00
    3.路由系统 4.视图 5.模板 6.session 7.flash 8.蓝图(blueprint) flask-组件 1.flask-session 2.DBUtils 3.wtforms 4.SQLAlchemy 5.flask-script 6.flask-migrate 偏函数 上下...
  • flask快速入门

    2020-01-27 15:11:29
    app.config 可以定义路由路由参数 app是应用程序实例. 路由返回字符串或者模版 返回字符串: returen ‘hello world’ 返回模版 : 前提: from flask import render_templates return render_template(‘index.html...
  • app = Flask(__name__) 是个什么东西

    千次阅读 2019-10-05 20:03:41
    例程: from flask import Flask app = Flask(__name__) # 新建一个Flask可运行实体(名字...app.debug = True # 可以通过此参数设置Flash的DEBUG模式参数 @app.route("/") # 在运行实体上绑定URL路由 def hel...
  • 例程: from flask import Flask app = Flask(__name__) # 新建一个Flask可运行...app.debug = True # 可以通过此参数设置Flash的DEBUG模式参数   @app.route("/") # 在运行实体上绑定URL路由 de...
  • Python与Web交互基础笔记

    千次阅读 2019-06-18 18:33:29
    1.Jinji2模板引擎(Falsk内置模板引擎,来源...2.定义路由入参(入参类型)以及路由请求格式(路由默认只支持GET请求) 例:通过<int>表明只接收orderId为int类型的参数,请求格式由methods=['','']格式实现 3....

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 378
精华内容 151
关键字:

flask路由传参