xinyin025/learn.lianglianglee.com
1
0
Fork 0
mirror of https://github.com/zhwei820/learn.lianglianglee.com.git synced 2025-09-17 08:46:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
learn.lianglianglee.com/专栏/白话设计模式 28 讲（完）/21 生活中的设计模式：那些未完待续的设计模式.md.html
周伟 d9c5ffd627 u
2022-05-11 19:04:14 +08:00

948 lines
28 KiB
HTML
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE html>
<!-- saved from url=(0046)https://kaiiiz.github.io/hexo-theme-book-demo/ -->
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0, user-scalable=no">
<link rel="icon" href="/static/favicon.png">
<title>21 生活中的设计模式：那些未完待续的设计模式.md.html</title>
<!-- Spectre.css framework -->
<link rel="stylesheet" href="/static/index.css">
<!-- theme css & js -->
<meta name="generator" content="Hexo 4.2.0">
</head>
<body>
<div class="book-container">
<div class="book-sidebar">
<div class="book-brand">
<a href="/">
<img src="/static/favicon.png">
<span>技术文章摘抄</span>
</a>
</div>
<div class="book-menu uncollapsible">
<ul class="uncollapsible">
<li><a href="/" class="current-tab">首页</a></li>
</ul>
<ul class="uncollapsible">
<li><a href="../">上一级</a></li>
</ul>
<ul class="uncollapsible">
<li>
<a href="/专栏/白话设计模式 28 讲（完）/00 生活中的设计模式：启程之前，请不要错过我.md.html">00 生活中的设计模式：启程之前，请不要错过我.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/01 监听模式：坑爹的热水器.md.html">01 监听模式：坑爹的热水器.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/02 适配模式：身高不够鞋来凑.md.html">02 适配模式：身高不够鞋来凑.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/03 状态模式：人与水的三态.md.html">03 状态模式：人与水的三态.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/04 单例模式：你是我生命的唯一.md.html">04 单例模式：你是我生命的唯一.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/05 职责模式：我的假条去哪了.md.html">05 职责模式：我的假条去哪了.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/06 中介模式：找房子问中介.md.html">06 中介模式：找房子问中介.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/07 代理模式：帮我拿一下快递.md.html">07 代理模式：帮我拿一下快递.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/08 装饰模式：你想怎么穿就怎么穿.md.html">08 装饰模式：你想怎么穿就怎么穿.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/09 工厂模式：你要拿铁还是摩卡.md.html">09 工厂模式：你要拿铁还是摩卡.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/10 迭代模式：下一个就是你了.md.html">10 迭代模式：下一个就是你了.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/11 组合模式：自己组装电脑.md.html">11 组合模式：自己组装电脑.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/12 构建模式：想要车还是庄园.md.html">12 构建模式：想要车还是庄园.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/13 克隆模式：给你一个分身术.md.html">13 克隆模式：给你一个分身术.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/14 策略模式：怎么来不重要，人到就行.md.html">14 策略模式：怎么来不重要，人到就行.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/15 命令模式：大闸蟹，走起！.md.html">15 命令模式：大闸蟹，走起！.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/16 备忘模式：好记性不如烂笔头.md.html">16 备忘模式：好记性不如烂笔头.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/17 享元模式：颜料很贵必须充分利用.md.html">17 享元模式：颜料很贵必须充分利用.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/18 外观模式：学妹别慌，学长帮你.md.html">18 外观模式：学妹别慌，学长帮你.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/19 访问模式：一千个读者一千个哈姆雷特.md.html">19 访问模式：一千个读者一千个哈姆雷特.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/20 生活中的设计模式：与经典设计模式的不解渊源.md.html">20 生活中的设计模式：与经典设计模式的不解渊源.md.html</a>
</li>
<li>
<a class="current-tab" href="/专栏/白话设计模式 28 讲（完）/21 生活中的设计模式：那些未完待续的设计模式.md.html">21 生活中的设计模式：那些未完待续的设计模式.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html">22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/23 深入解读对象池技术：共享让生活更便捷.md.html">23 深入解读对象池技术：共享让生活更便捷.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/24 深入解读回调机制：把你技能亮出来.md.html">24 深入解读回调机制：把你技能亮出来.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/25 谈谈我对设计模式的理解.md.html">25 谈谈我对设计模式的理解.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/26 谈谈我对设计原则的思考.md.html">26 谈谈我对设计原则的思考.md.html</a>
</li>
<li>
<a href="/专栏/白话设计模式 28 讲（完）/27 谈谈我对项目重构的看法.md.html">27 谈谈我对项目重构的看法.md.html</a>
</li>
</ul>
</div>
</div>
<div class="sidebar-toggle" onclick="sidebar_toggle()" onmouseover="add_inner()" onmouseleave="remove_inner()">
<div class="sidebar-toggle-inner"></div>
</div>
<script>
function add_inner() {
let inner = document.querySelector('.sidebar-toggle-inner')
inner.classList.add('show')
}
function remove_inner() {
let inner = document.querySelector('.sidebar-toggle-inner')
inner.classList.remove('show')
}
function sidebar_toggle() {
let sidebar_toggle = document.querySelector('.sidebar-toggle')
let sidebar = document.querySelector('.book-sidebar')
let content = document.querySelector('.off-canvas-content')
if (sidebar_toggle.classList.contains('extend')) { // show
sidebar_toggle.classList.remove('extend')
sidebar.classList.remove('hide')
content.classList.remove('extend')
} else { // hide
sidebar_toggle.classList.add('extend')
sidebar.classList.add('hide')
content.classList.add('extend')
}
}
function open_sidebar() {
let sidebar = document.querySelector('.book-sidebar')
let overlay = document.querySelector('.off-canvas-overlay')
sidebar.classList.add('show')
overlay.classList.add('show')
}
function hide_canvas() {
let sidebar = document.querySelector('.book-sidebar')
let overlay = document.querySelector('.off-canvas-overlay')
sidebar.classList.remove('show')
overlay.classList.remove('show')
}
</script>
<div class="off-canvas-content">
<div class="columns">
<div class="column col-12 col-lg-12">
<div class="book-navbar">
<!-- For Responsive Layout -->
<header class="navbar">
<section class="navbar-section">
<a onclick="open_sidebar()">
<i class="icon icon-menu"></i>
</a>
</section>
</header>
</div>
<div class="book-content" style="max-width: 960px; margin: 0 auto;
overflow-x: auto;
overflow-y: hidden;">
<div class="book-post">
<p id="tip" align="center"></p>
<div><h1>21 生活中的设计模式：那些未完待续的设计模式</h1>
<p>随着技术的不断革新与发展，设计模式也一直在发展，有一些模式已不再常用，同时却有一些新的模式在诞生。本课程并未对这 23 种设计模式都进行一一讲解，因为有一些设计模式在现今软件的开发中用的非常少！而有一些却在面向对象中应用的太频繁，以至于我们都不认为它是一种模式。前面已经讲解了 19 种设计模式，下面将对未提及的 4 种设计模式一并进行说明。</p>
<h3>抽象工厂</h3>
<p>这个模式与工厂方法模式相比，在实际应用项目中使用的相对较少。一谈到工厂模式，大家一定会想到工厂三姐妹：简单工厂模式、工厂方法模式、抽象工厂模式，这一部分的内容在《[生活中的工厂模式——你要拿铁还是摩卡]》一文的 <em>拓展：工厂三姐妹</em> 的部分已经做了较详细的说明，读者可跳转这一课程中进行阅读。</p>
<h3>模板模式</h3>
<p>这一模式非常简单，以至于我都不觉得它是一个模式。因为只要是在使用面向对象的语言进行开发时，在有意无意之中就已经在使用它了，举一个例子。</p>
<h4>Demo</h4>
<p><em>在阅读电子书时，根据每个人的不同阅读习惯，可以设置不同的翻页方式，如左右平滑、仿真翻页等，不同的翻页方式，会给人以不同的展示效果。</em></p>
<p>根据这一需求，我们用程序来模拟实现一下效果。</p>
<pre><code class="language-python">from abc import ABCMeta, abstractmethod
# 引入ABCMeta和abstractmethod来定义抽象类和抽象方法
class ReaderView(metaclass=ABCMeta):
&quot;阅读器视图&quot;
def __init__(self):
self.__curPageNum = 1
def getPage(self, pageNum):
self.__curPageNum = pageNum
return &quot;第&quot; + str(pageNum) + &quot;的内容&quot;
def prePage(self):
content = self.getPage(self.__curPageNum - 1)
self.displayPage(content)
def nextPage(self):
content = self.getPage(self.__curPageNum + 1)
self.displayPage(content)
@abstractmethod
def displayPage(self, content):
&quot;翻页效果&quot;
pass
class SmoothView(ReaderView):
&quot;左右平滑的视图&quot;
def displayPage(self, content):
print(&quot;左右平滑:&quot; + content)
class SimulationView(ReaderView):
&quot;仿真翻页的视图&quot;
def displayPage(self, content):
print(&quot;仿真翻页:&quot; + content)
</code></pre>
<p>你看，是不是非常简单，因为模板方法模式只是用了面向对象的继承机制。而这种继承方式，在写代码的时候可能在很多地方已经有意无意的就这么使用了。</p>
<blockquote>
<p>Define the skeleton of an algorithm in an operation, deferring some steps to client subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.</p>
<p>在父类中提供了一个定义算法框架的模板方法，而将算法中用到的具体的步骤放到子类中去实现，使得子类可以在不改变算法的同时重新定义该算法的某些特定步骤。</p>
</blockquote>
<h4>代码框架</h4>
<p>我们对上面的示例代码进行进一步的重构和优化，抽象出模板模式的框架模型。</p>
<pre><code class="language-python">from abc import ABCMeta, abstractmethod
# 引入ABCMeta和abstractmethod来定义抽象类和抽象方法
class Template(metaclass=ABCMeta):
&quot;模板类(抽象类)&quot;
@abstractmethod
def stepOne(self):
pass
@abstractmethod
def stepTwo(self):
pass
@abstractmethod
def stepThree(self):
pass
def templateMethold(self):
&quot;模板方法&quot;
self.stepOne()
self.stepTwo()
self.stepThree()
class TemplateImplA(Template):
&quot;模板实现类A&quot;
def stepOne(self):
print(&quot;步骤一&quot;)
def stepTwo(self):
print(&quot;步骤二&quot;)
def stepThree(self):
print(&quot;步骤三&quot;)
class TemplateImplB(Template):
&quot;模板实现类B&quot;
def stepOne(self):
print(&quot;Step one&quot;)
def stepTwo(self):
print(&quot;Step two&quot;)
def stepThree(self):
print(&quot;Step three&quot;)
</code></pre>
<h4>类图</h4>
<p>模板方法模式的类图表示如下：</p>
<p><img src="assets/eed01e10-8e4e-11e8-91f2-2b35ab59bab9.jpg" alt="enter image description here" /></p>
<p>Template 是一个模板类，用于定义模板方法（某种算法的框架），如示例中的 ReaderView。TemplateImplA 和 TemplateImplB 是模板类的具体子类，用于实现算法框架中的一些特定步骤。</p>
<h4>应用场景</h4>
<ul>
<li>对一些复杂的算法进行分割，将其算法中固定不变的部分设计为模板方法和父类具体方法，而一些可以改变的细节由其子类来实现。即一次性实现一个算法的不变部分，并将可变的行为留给子类来实现。</li>
<li>各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。</li>
<li>需要通过子类来决定父类算法中某个步骤是否执行，以实现子类对父类的反向控制。</li>
</ul>
<h3>桥接模式</h3>
<p>这个模式可以和策略模式合为一个模式，因为思想相同，代码结构也几乎一样，如下图它们的类图结构几乎相同，只是一个（策略模式）侧重于对象行为，一个（桥接模式）侧重于软件结构。</p>
<h4>类图</h4>
<p><img src="assets/61f84020-8e4f-11e8-9cd7-51dfc6c66063.jpg" alt="enter image description here" /></p>
<p>策略模式的类图</p>
<p><img src="assets/73af29a0-8e4f-11e8-9d8f-6d52f659a2b6.jpg" alt="enter image description here" /></p>
<p>桥接模式的类图</p>
<p>从类图可以看出，桥梁模式和策略模式几乎是一样的，只是多了对抽象（Abstraction）的具体实现类，用于对抽象化角色进行修正。</p>
<h4>桥接模式</h4>
<blockquote>
<p>Decouple an abstraction from its implementation so that the two can vary independently.</p>
<p>将抽象和实现解耦，使得它们可以独立地变化。</p>
</blockquote>
<p>桥梁模式关注的是抽象和实现的分离，使得它们可以独立地发展；桥梁模式是结构型模式，侧重于软件结构。而策略模式关注的是对算法、规则的封装，使得算法可以独立于使用它的用户而变化；策略模式是行为型模式，侧重于对象行为。</p>
<p>设计模式其实就是一种编程思想，没有固定的结构。区分不同的模式，更多的是要从语义和用途是判断。</p>
<h4>应用案例</h4>
<p>在几何图形的分类中，假设我们有矩形和椭圆之分，这时又希望加入颜色（红色、绿色）来拓展它的层级。如果用一般继承的思想，则会有下面这样的类图：</p>
<p><img src="assets/85d99570-8e4f-11e8-a3e9-3b5653895392.jpg" alt="enter image description here" /></p>
<p>如果再增加几个形状（如三角形），再增加几种颜色（如蓝色、紫色），这个类图将会越来越膨胀和臃肿。这时，我们就希望对这个设计进行解耦，将形状和颜色分成两个分支，独立发展，互不影响。桥接模式就派上用场了，我们看一下使用桥接模式后的类图：</p>
<p><img src="assets/947d99a0-8e4f-11e8-91f2-2b35ab59bab9.jpg" alt="enter image description here" /></p>
<p>实现代码如下：</p>
<pre><code class="language-python">from abc import ABCMeta, abstractmethod
# 引入ABCMeta和abstractmethod来定义抽象类和抽象方法
class Shape(metaclass=ABCMeta):
&quot;形状&quot;
def __init__(self, color):
self._color = color
@abstractmethod
def getShapeType(self):
pass
def getShapeInfo(self):
return self._color.getColor() + &quot;的&quot; + self.getShapeType()
class Rectange(Shape):
&quot;矩形&quot;
def __init__(self, color):
super().__init__(color)
def getShapeType(self):
return &quot;矩形&quot;
class Ellipse(Shape):
&quot;椭圆&quot;
def __init__(self, color):
super().__init__(color)
def getShapeType(self):
return &quot;椭圆&quot;
class Color(metaclass=ABCMeta):
&quot;颜色&quot;
@abstractmethod
def getColor(self):
pass
class Red(Color):
&quot;红色&quot;
def getColor(self):
return &quot;红色&quot;
class Green(Color):
&quot;绿色&quot;
def getColor(self):
return &quot;绿色&quot;
</code></pre>
<p>测试代码如下：</p>
<pre><code class="language-python">def testShap():
redRect = Rectange(Red())
print(redRect.getShapeInfo())
greenRect = Rectange(Green())
print(greenRect.getShapeInfo())
redEllipse = Ellipse(Red())
print(redEllipse.getShapeInfo())
greenEllipse = Ellipse(Green())
print(greenEllipse.getShapeInfo())
</code></pre>
<p>结果如下：</p>
<pre><code>红色的矩形
绿色的矩形
红色的椭圆
绿色的椭圆
</code></pre>
<h3>解释模式</h3>
<h4>解释模式</h4>
<p>解释模式又叫解释器模式，它是一种使用频率相对较低但学习难度较大的设计模式，它用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。如在金融业务中，经常需要定义一些模型运算来统计、分析大量的金融数据，从而窥探一些商业发展趋势。</p>
<blockquote>
<p>Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.</p>
<p>定义一个语言，定义它的文法的一种表示；并定义一个解释器，该解释器使用该文法来解释语言中的句子。</p>
</blockquote>
<h4>类图</h4>
<p>解释模式的类图表示如下：</p>
<p><img src="assets/a7dd9f40-8e4f-11e8-80d1-2d51ff7e1c55.jpg" alt="enter image description here" /></p>
<p>AbstractExpression 解释器的抽象类，定义统一的解析方法。TerminalExpression 是终结符表达式，终结符表达式是语法中的最小单元逻辑，不可再拆分，如下面示例中的 VarExpression。</p>
<p>NonTerminalExpression 是非终结符表达式，方法中每一条规则对应一个非终结表达式，如下面示例中的 AddExpression 和 SubExpression。Context 是上下文环境类，包含解析器之外的一些全局信息，如下面示例中的 newExp 和 expressionMap。</p>
<h4>应用案例</h4>
<p>我们用数学中最简单的加减法来讲解解释器模式的应用。假设有如下两个表达式规则：</p>
<pre><code>a+b+c
a+b-c
</code></pre>
<p>用解释器来解释具体的内容。</p>
<pre><code class="language-python">from abc import ABCMeta, abstractmethod
# 引入ABCMeta和abstractmethod来定义抽象类和抽象方法
class Expression(metaclass=ABCMeta):
&quot;抽象表达式&quot;
@abstractmethod
def interpreter(self, var):
pass
class VarExpression(Expression):
&quot;变量解析器&quot;
def __init__(self, key):
self.__key = key
def interpreter(self, var):
return var.get(self.__key)
class SymbolExpression(Expression):
&quot;运算符解析器，运算符的抽象类&quot;
def __init__(self, left, right):
self._left = left
self._right = right
class AddExpression(SymbolExpression):
&quot;加法解析器&quot;
def __init__(self, left, right):
super().__init__(left, right)
def interpreter(self, var):
return self._left.interpreter(var) + self._right.interpreter(var)
class SubExpression(SymbolExpression):
&quot;减法解析器&quot;
def __init__(self, left, right):
super().__init__(left, right)
def interpreter(self, var):
return self._left.interpreter(var) - self._right.interpreter(var)
# import stack
class Calculator:
&quot;计算器类&quot;
def __init__(self, text):
self.__expression = self.parserText(text)
def parserText(self, expText):
# 定义一个栈，处理运算的先后顺序
stack = Stack()
left = right = None # 左右表达式
idx = 0
while(idx &lt; len(expText)):
if (expText[idx] == '+'):
left = stack.pop()
idx += 1
right = VarExpression(expText[idx])
stack.push(AddExpression(left, right))
elif(expText[idx] == '-'):
left = stack.pop()
idx += 1
right = VarExpression(expText[idx])
stack.push(SubExpression(left, right))
else:
stack.push(VarExpression(expText[idx]))
idx += 1
return stack.pop()
def run(self, var):
return self.__expression.interpreter(var)
class Stack:
&quot;封装一个堆栈类&quot;
def __init__(self):
self.items = []
def isEmpty(self):
return len(self.items) == 0
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
if not self.isEmpty():
return self.items[len(self.items) - 1]
def size(self):
return len(self.items)
</code></pre>
<p>测试代码：</p>
<pre><code class="language-python">def testCalculator():
# 获取表达式
expStr = input(&quot;请输入表达式：&quot;);
# 获取各参数的键值对
newExp, expressionMap = getMapValue(expStr)
calculator = Calculator(newExp)
result = calculator.run(expressionMap)
print(&quot;运算结果为:&quot; + expStr + &quot; = &quot; + str(result))
def getMapValue(expStr):
preIdx = 0
expressionMap = {}
newExp = []
for i in range(0, len(expStr)):
if (expStr[i] == '+' or expStr[i] == '-'):
key = expStr[preIdx:i]
key = key.strip() # 去除前后空字符
newExp.append(key)
newExp.append(expStr[i])
var = input(&quot;请输入参数&quot; + key + &quot;的值：&quot;);
var = var.strip()
expressionMap[key] = float(var)
preIdx = i + 1
# 处理最后一个参数
key = expStr[preIdx:len(expStr)]
key = key.strip() # 去除前后空字符
newExp.append(key)
var = input(&quot;请输入参数&quot; + key + &quot;的值：&quot;);
var = var.strip()
expressionMap[key] = float(var)
return newExp, expressionMap
</code></pre>
<p>结果如下：</p>
<p><img src="assets/b940ea80-8e4f-11e8-91f2-2b35ab59bab9.jpg" alt="enter image description here" /></p>
<p>解释器模式是一个简单的语法分析工具，最显著的优点是拓展性，修改语法规则只要修改相应的非终结符表达式就可以了。解释器模式在实际的项目开发中应用的比较少，因为现实复杂，较难维护，但在一些特定的领域还是会被用到，如数据分析、科学计算、数据统计与报表分析。</p>
</div>
</div>
<div>
<div style="float: left">
<a href="/专栏/白话设计模式 28 讲（完）/20 生活中的设计模式：与经典设计模式的不解渊源.md.html">上一页</a>
</div>
<div style="float: right">
<a href="/专栏/白话设计模式 28 讲（完）/22 深入解读过滤器模式：制作一杯鲜纯细腻的豆浆.md.html">下一页</a>
</div>
</div>
</div>
</div>
</div>
</div>
<a class="off-canvas-overlay" onclick="hide_canvas()"></a>
</div>
<script defer src="https://static.cloudflareinsights.com/beacon.min.js/v652eace1692a40cfa3763df669d7439c1639079717194" integrity="sha512-Gi7xpJR8tSkrpF7aordPZQlW2DLtzUlZcumS8dMQjwDHEnw9I7ZLyiOj/6tZStRBGtGgN6ceN6cMH8z7etPGlw==" data-cf-beacon='{"rayId":"70997baa784e3cfa","version":"2021.12.0","r":1,"token":"1f5d475227ce4f0089a7cff1ab17c0f5","si":100}' crossorigin="anonymous"></script>
</body>
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-NPSEEVD756"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag() {
dataLayer.push(arguments);
}
gtag('js', new Date());
gtag('config', 'G-NPSEEVD756');
var path = window.location.pathname
var cookie = getCookie("lastPath");
console.log(path)
if (path.replace("/", "") === "") {
if (cookie.replace("/", "") !== "") {
console.log(cookie)
document.getElementById("tip").innerHTML = "<a href='" + cookie + "'>跳转到上次进度</a>"
}
} else {
setCookie("lastPath", path)
}
function setCookie(cname, cvalue) {
var d = new Date();
d.setTime(d.getTime() + (180 * 24 * 60 * 60 * 1000));
var expires = "expires=" + d.toGMTString();
document.cookie = cname + "=" + cvalue + "; " + expires + ";path = /";
}
function getCookie(cname) {
var name = cname + "=";
var ca = document.cookie.split(';');
for (var i = 0; i < ca.length; i++) {
var c = ca[i].trim();
if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
}
return "";
}
</script>
</html>
Reference in New Issue View Git Blame Copy Permalink