一个 Python 和 JavaScript 交换数据的库

开发 后端
telepath是一个Django库,用于在Python和JavaScript之间交换数据,使您可以构建具有丰富客户端接口的应用程序,同时将业务逻辑保留在服务器端代码中。

[[400553]]

本文转载自微信公众号「Python中文社区」,作者telepath。转载本文请联系Python中文社区公众号。

 telepath是一个Django库,用于在Python和JavaScript之间交换数据,使您可以构建具有丰富客户端接口的应用程序,同时将业务逻辑保留在服务器端代码中。

它有什么作用?

它提供了一种将包括Python对象在内的结构化数据打包为JSON可序列化格式的机制。通过向相应的JavaScript实现注册该机制,可以扩展该机制以支持任何Python类。然后,打包的数据可以包含在HTTP响应中,并在JavaScript中解压缩以获得与原始数据等效的数据结构。

安装方法

  1. pip install telepath 

并将'telepath'添加到项目的INSTALLED_APPS。

简介

假设我们正在构建一个用于玩跳棋的Django应用。我们已经花费了数天或数周的时间,构建了游戏规则的Python实现,并提供了代表当前游戏状态和各个部分的类。但是,我们还希望为播放器提供一个适当友好的用户界面,这意味着该是我们编写JavaScript前端的时候了。我们的UI代码不可避免地将拥有自己的对象,这些对象代表不同的角色,镜像我们正在服务器上跟踪的数据结构——但我们无法发送Python对象,因此将这些数据发送到客户端通常将意味着设计游戏状态的JSON表示形式,并在两端分别设计大量样式代码,遍历数据结构以在本机对象之间来回转换。让我们看看telepath如何简化该过程。

一个完整的跳棋游戏对于本教程来说有点太多了,所以我们只选择渲染这一步...

在Python环境中,创建一个新的Django项目:

  1. pip install "Django>=3.1,<3.2" 
  2. django-admin startproject draughts 
  3. cd draughts 
  4. ./manage.py startapp games 

在draughts / settings.py的INSTALLED_APPS列表中添加'games'。

为简单起见,在本示例中,我们将不涉及数据库,而是将游戏状态表示为普通的Python类而不是Django模型。修改games/views.py,如下所示:

  1. from django.shortcuts import render 
  2.  
  3.  
  4. class Piece: 
  5.     def __init__(self, color, position): 
  6.         self.color = color 
  7.         self.position = position 
  8.  
  9.  
  10. class GameState: 
  11.     def __init__(self, pieces): 
  12.         self.pieces = pieces 
  13.  
  14.     @staticmethod 
  15.     def new_game(): 
  16.         black_pieces = [ 
  17.             Piece('black', (x, y)) 
  18.             for y in range(0, 3) 
  19.             for x in range((y + 1) % 2, 8, 2) 
  20.         ] 
  21.         white_pieces = [ 
  22.             Piece('white', (x, y)) 
  23.             for y in range(5, 8) 
  24.             for x in range((y + 1) % 2, 8, 2) 
  25.         ] 
  26.         return GameState(black_pieces + white_pieces) 
  27.  
  28.  
  29. def game(request): 
  30.     game_state = GameState.new_game() 
  31.  
  32.     return render(request, 'game.html', {}) 

如下所示创建games/templates/game.html:

  1. <!doctype html> 
  2. <html> 
  3.     <head> 
  4.         <title>Draughts</title> 
  5.         <script> 
  6.             document.addEventListener('DOMContentLoaded', event => { 
  7.                 const gameElement = document.getElementById('game'); 
  8.                 gameElement.innerHTML = 'TODO: render the board here' 
  9.             }); 
  10.         </script> 
  11.     </head> 
  12.     <body> 
  13.         <h1>Draughts</h1> 
  14.         <div id="game"
  15.         </div> 
  16.     </body> 
  17. </html> 

 

 

 

 

 

 

 

将新视图添加到draughts/urls.py:

  1. from django.contrib import admin 
  2. from django.urls import path 
  3.  
  4. from games.views import game 
  5.  
  6. urlpatterns = [ 
  7.     path('', game), 
  8.     path('admin/', admin.site.urls), 

现在,使用./manage.py runserver启动服务器,并访问http:// localhost:8000 /。

到目前为止,我们已经创建了一个代表新游戏的GameState对象——现在是时候引入telepath,以便我们可以将该对象传输到客户端。执行下面命令:

  1. pip install telepath 

并将'telepath'添加到draughts / settings.py中的INSTALLED_APPS列表中。现在编辑games/views.py文件:

  1. import json 
  2. from django.shortcuts import render 
  3. from telepath import JSContext 
  4.  
  5. # ... 
  6.  
  7. def game(request): 
  8.     game_state = GameState.new_game() 
  9.  
  10.     js_context = JSContext() 
  11.     packed_game_state = js_context.pack(game_state) 
  12.     game_state_json = json.dumps(packed_game_state) 
  13.  
  14.     return render(request, 'game.html', { 
  15.         'game_state_json': game_state_json, 
  16.     }) 

这里JSContext是一个帮助工具,用于管理游戏状态对象到我们可以在Javascript中使用的表示形式的转换。js_context.pack接受该对象并将其转换为可以JSON序列化并传递到我们的模板的值。但是,现在重新加载页面失败,并出现以下形式的错误:don't know how to pack object:

这是因为GameState是Telepath尚不知道如何处理的自定义Python类型。传递给pack的任何自定义类型必须链接到相应的JavaScript实现;这是通过定义Adapter对象并将其注册到telepath来完成的。如下更新game / views.py:

  1. import json 
  2. from django.shortcuts import render 
  3. from telepath import Adapter, JSContext, register 
  4.  
  5. # ... 
  6.  
  7. class GameState: 
  8.     # keep definition as before 
  9.  
  10.  
  11. class GameStateAdapter(Adapter): 
  12.     js_constructor = 'draughts.GameState' 
  13.  
  14.     def js_args(self, game_state): 
  15.         return [game_state.pieces] 
  16.  
  17.     class Media: 
  18.         js = ['draughts.js'
  19.  
  20.  
  21. register(GameStateAdapter(), GameState) 

此处js_constructor是JavaScript构造函数的标识符,该标识符将用于在客户端上构建GameState实例,并且js_args定义了将传递给此构造函数的参数列表,以重新创建给定game_state对象的JavaScript对应对象 。Media类指示文件,该文件遵循Django对格式媒体的约定,可在其中找到GameState的JavaScript实现。稍后我们将看到此JavaScript实现的外观,现在,我们需要为Piece类定义一个类似的适配器,因为我们对GameStateAdapter的定义取决于是否能够打包Piece实例。将以下定义添加到games/views.py:

  1. class Piece: 
  2.     # keep definition as before 
  3.  
  4.  
  5. class PieceAdapter(Adapter): 
  6.     js_constructor = 'draughts.Piece' 
  7.  
  8.     def js_args(self, piece): 
  9.         return [piece.color, piece.position] 
  10.  
  11.     class Media: 
  12.         js = ['draughts.js'
  13.  
  14.  
  15. register(PieceAdapter(), Piece) 

重新加载页面,您将看到错误提示消失了,这表明我们已成功将GameState对象序列化为JSON并将其传递给模板。现在,我们可以将其包含在模板中-编辑games/templates/game.html:

  1. <body> 
  2.        <h1>Draughts</h1> 
  3.        <div id="game" data-game-state="{{ game_state_json }}"
  4.        </div> 
  5.    </body> 

 

 

 

 

 

 

再次重新加载页面,并在浏览器的开发人员工具中检查游戏元素(在Chrome和Firefox中,右键单击TODO注释,然后选择Inspect或Inspect Element),您将看到GameState对象的JSON表示,准备好 解压成完整的JavaScript对象。

除了将数据打包成JSON可序列化的格式外,JSContext对象还跟踪将数据解压缩所需的JavaScript媒体定义,作为其媒体属性。让我们更新游戏视图,以将其也传递给模板-在games/views.py中:

  1. def game(request): 
  2.     game_state = GameState.new_game() 
  3.  
  4.     js_context = JSContext() 
  5.     packed_game_state = js_context.pack(game_state) 
  6.     game_state_json = json.dumps(packed_game_state) 
  7.  
  8.     return render(request, 'game.html', { 
  9.         'game_state_json': game_state_json, 
  10.         'media': js_context.media, 
  11.     }) 

将下面代码添加到games / templates / game.html中的HTML头文件中:

  1. <head> 
  2.         <title>Draughts</title> 
  3.         {{ media }} 
  4.         <script> 
  5.             document.addEventListener('DOMContentLoaded', event => { 
  6.                 const gameElement = document.getElementById('game'); 
  7.                 gameElement.innerHTML = 'TODO: render the board here' 
  8.             }); 
  9.         </script> 
  10.     </head> 

 

 

重新加载页面并查看源代码,您将看到这带来了两个JavaScript包括 —— telepath.js(客户端telepath库,提供解包机制)和我们在适配器定义中指定的draughts.js文件。后者尚不存在,所以让我们在games / static / draughts.js中创建它:

  1. class Piece { 
  2.     constructor(color, position) { 
  3.         this.color = color; 
  4.         this.position = position; 
  5.     } 
  6. window.telepath.register('draughts.Piece', Piece); 
  7.  
  8.  
  9. class GameState { 
  10.     constructor(pieces) { 
  11.         this.pieces = pieces; 
  12.     } 
  13. window.telepath.register('draughts.GameState', GameState); 

这两个类定义实现了我们先前在适配器对象中声明的构造函数-构造函数接收的参数是js_args定义的参数。window.telepath.register行将这些类定义附加到通过js_constructor指定的相应标识符。现在,这为我们提供了解压缩JSON所需的一切-回到games / templates / game.html中,更新JS代码,如下所示:

  1. <script> 
  2.            document.addEventListener('DOMContentLoaded', event => { 
  3.                const gameElement = document.getElementById('game'); 
  4.                const gameStateJson = gameElement.dataset.gameState; 
  5.                const packedGameState = JSON.parse(gameStateJson); 
  6.                const gameState = window.telepath.unpack(packedGameState); 
  7.                console.log(gameState); 
  8.            }) 
  9.        </script> 

 

您可能需要重新启动服务器以获取新的games/static文件夹。重新加载页面,然后在浏览器控制台中,您现在应该看到填充了Piece对象的GameState对象。现在,我们可以继续在games/static/draughts.js中填写渲染代码:

  1. class Piece { 
  2.     constructor(color, position) { 
  3.         this.color = color; 
  4.         this.position = position; 
  5.     } 
  6.  
  7.     render(container) { 
  8.         const element = document.createElement('div'); 
  9.         container.appendChild(element); 
  10.         element.style.width = element.style.height = '24px'
  11.         element.style.border = '2px solid grey'
  12.         element.style.borderRadius = '14px'
  13.         element.style.backgroundColor = this.color; 
  14.     } 
  15. window.telepath.register('draughts.Piece', Piece) 
  16.  
  17.  
  18. class GameState { 
  19.     constructor(pieces) { 
  20.         this.pieces = pieces; 
  21.     } 
  22.  
  23.     render(container) { 
  24.         const table = document.createElement('table'); 
  25.         container.appendChild(table); 
  26.         const cells = []; 
  27.         for (let y = 0; y < 8; y++) { 
  28.             let row = document.createElement('tr'); 
  29.             table.appendChild(row); 
  30.             cells[y] = []; 
  31.             for (let x = 0; x < 8; x++) { 
  32.                 let cell = document.createElement('td'); 
  33.                 row.appendChild(cell); 
  34.                 cells[y][x] = cell; 
  35.                 cell.style.width = cell.style.height = '32px'
  36.                 cell.style.backgroundColor = (x + y) % 2 ? 'silver''white'
  37.             } 
  38.         } 
  39.  
  40.         this.pieces.forEach(piece => { 
  41.             const [x, y] = piece.position; 
  42.             const cell = cells[y][x]; 
  43.             piece.render(cell); 
  44.         }); 
  45.     } 
  46. window.telepath.register('draughts.GameState', GameState) 

在games/templates/game.html中添加对render方法的调用:

  1. <script> 
  2.             document.addEventListener('DOMContentLoaded', event => { 
  3.                 const gameElement = document.getElementById('game'); 
  4.                 const gameStateJson = gameElement.dataset.gameState; 
  5.                 const packedGameState = JSON.parse(gameStateJson); 
  6.                 const gameState = window.telepath.unpack(packedGameState); 
  7.                 gameState.render(gameElement); 
  8.             }) 
  9.         </script> 

 

重新加载页面,您将看到我们的跳棋程序已准备就绪,可以开始游戏了。

  • 让我们快速回顾一下我们已经取得的成果:
  • 我们已经打包和解包了自定义Python / JavaScript类型的数据结构,而无需编写代码来递归该结构。如果我们的GameState对象变得更复杂(例如,“棋子”列表可能变成棋子和国王对象的混合列表,或者状态可能包括游戏历史),则无需重构任何数据打包/拆包逻辑,除了为每个使用的类提供一个适配器对象。
  • 仅提供了解压缩页面数据所需的JS文件-如果我们的游戏应用程序扩展到包括Chess,Go和Othello,并且所有生成的类都已通过Telepath注册,则我们仍然只需要提供与跳棋知识相关的代码。

即使我们使用任意对象,也不需要动态内联JavaScript —— 所有动态数据都以JSON形式传递,并且所有JavaScript代码在部署时都是固定的(如果我们的网站强制执行CSP,这一点很重要)。

责任编辑:武晓燕 来源: Python中文社区
相关推荐

2014-02-14 09:37:01

JavascriptDOM

2021-05-14 10:45:21

PythonNoSQL数据库

2012-07-17 17:05:55

JavaScript

2012-12-12 09:47:56

JavaScript

2017-05-18 12:16:03

LinuxPythonNoSql

2022-07-21 09:50:20

Python日期库pendulum

2023-11-28 14:22:54

Python音频

2011-07-20 14:57:47

SQLite数据库ORDER BYGROUP BY

2011-07-20 13:18:01

SQLite数据库修改和删除数据

2012-01-04 13:55:23

Canvas

2021-07-29 10:46:56

Python内置库代码

2021-08-27 09:48:18

Pythonitertools代码

2018-02-25 17:30:18

2011-07-20 13:40:00

SQLite数据库查询数据

2022-08-31 12:48:48

TinyDBPython数据库

2011-10-13 09:38:27

JavaScript

2017-11-21 09:30:00

2017-04-10 10:35:02

JavaScript框架

2011-07-20 14:32:59

SQLite数据库LIKE查询IN集合查询

2011-08-18 18:18:05

MySQL数据库优化
点赞
收藏

51CTO技术栈公众号