Sails.js를 사용하여 데이터 처리

Sails.js는 자유로움과 현명한 기본값에 초점을 맞춘 신흥 Node.js 프레임워크입니다. 이 기사에서는 복잡한 애플리케이션을 쉽게 만들기 위해 Sails가 제공하는 기본 데이터 기능 중 일부를 살펴보겠습니다.

---

Sails가 다른 프레임워크와 다른 이유

Sails를 선택한 이유는 Sails의 창시자인 Mike McNeil이 "Sails는 필요에 의해 만들어졌다"라고 가장 잘 말했습니다. 여러분이 보고 있는 많은 프레임워크는 거의 항상 학문적 측면을 위해 구축되었습니다. 이러한 프레임워크는 일반적으로 모범 사례를 장려하고 개발자가 더 빠르고 더 나은 것을 만들 수 있는 플랫폼을 만듭니다.

Sails는 프로덕션용으로 만들어졌으며 새로운 구문이나 플랫폼을 제공하려는 것이 아니라 "클라이언트 작업"을 신속하게 생성하도록 설계된 견고한 기반을 제공합니다. 대비가 미묘할 수 있지만 눈에 띄는 차이가 있습니다.

내가 말하는 내용을 설명하기 위해 Meteor를 살펴보겠습니다. Meteor는 오늘날 최고의 JS 플랫폼일 수 있지만 프레임워크를 위한 프레임워크의 대표적인 예입니다. 그건 나쁜 일이 아닙니다. 저는 Meteor의 열렬한 지지자입니다. 그들은 프레임워크를 구축하기 시작했고 훌륭한 일을 해냈습니다. 반면에 Mike는 고객이 더 빠르게 작업할 수 있도록 시작했습니다. 돛은 목적을 위한 수단일 뿐입니다.

Meteor에서는 거의 모든 것이 추상화되어 있으며 JavaScript와 Meteor API를 사용하여 모든 것을 코딩할 수 있습니다. 그리고 Sails는 새로운 플랫폼이 아니기 때문에 숨겨진 것이 없습니다.

Socket.io와 널리 사용되는 Express 프레임워크를 기반으로 구축되어 기본적으로 모든 기능에 액세스할 수 있습니다. 차이가 보이기 시작했나요?

또한 Sails는 프로덕션을 위해 먼저 제작되었기 때문에 다양한 확장 및 보안 옵션이 있습니다.

할 이야기가 많지만 이 기사에서는 Sails가 데이터를 처리하는 방법과 Sails의 고급 기능을 활용하여 정말 멋진 작업을 수행하는 방법에 중점을 두고 싶습니다.

---

설치

아직 Sails가 설치되지 않은 경우 NPM을 통해 다음 명령을 실행하여 설치할 수 있습니다.

으아악

---

Socket.io 및 Express

이제 Sails에 대해 논의하기 전에 Socket.io와 Express에 대해 이야기해 보겠습니다. 관심이 있으시면 Andrew Burgess의 Express에 대한 좋은 고급 시리즈가 있지만 여기에서는 두 라이브러리의 기본 사항을 다루겠습니다.

Socket.io

Socket.io는 서버와 클라이언트에서 실행되고 웹 소켓을 통해 통신할 수 있게 해주는 pub/sub 라이브러리입니다.

간단한 예는 다음과 같습니다:

으아악

이 코드는 먼저 socket.io 库，侦听连接，然后当另一个套接字连接时，它将向其发送一条消息，发送给 welcomeMessage 이벤트를 사용하고 마지막으로 일부 JSON을 전달합니다.

다음으로 클라이언트에서 다음을 작성합니다.

으아악

여기서 서버에 연결하여 방금 생성한 welcomeMessage 이벤트를 듣습니다. 보시다시피 이는 양방향인 매우 간단한 게시/구독 서버입니다(클라이언트가 서버에 메시지를 보낼 수도 있음).

이제 Express를 살펴보겠습니다.

빠른 배송

빠른 경로의 가장 간단한 형태는 다음과 같습니다.

으아악

사용자가 귀하의 웹사이트 주소를 방문하여 /users 页面时，他们将看到消息 “Hello from '/users' !”접속을 시도할 때 간단한 경로를 정의합니다.

So Express는 HTTP 요청을 처리하기 위한 프레임워크인 반면 Socket.io는 웹소켓 통신 라이브러리입니다. Sails 팀이 수행한 작업은 내부적으로 모든 Express 경로를 Socket.io에 매핑하는 것입니다. 이는 웹 소켓을 통해 모든 HTTP 경로를 호출할 수 있음을 의미합니다.

이제 정말 멋지네요! 그러나 퍼즐의 한 조각이 아직 빠져 있는데, 바로 돛 설계도입니다.

Sails를 사용하면 다른 프레임워크와 마찬가지로 모델을 생성할 수 있습니다. 단, 프로덕션에 사용할 수 있는 RESTfull API도 생성할 수 있다는 점이 다릅니다. 이는 "users”的模型，您可以立即对“/users"라는 리소스를 생성하는 경우 코딩 없이 RESTfull 쿼리를 실행한다는 의미입니다.

RESTful API에 익숙하지 않다면 이는 CRUD 작업이 다양한 HTTP 메서드에 매핑되는 데이터에 액세스하는 방법일 뿐입니다.

그래서 '/users' 的 GET 请求将获取所有用户，POST' 요청을 하면 새 사용자가 생성됩니다.

그럼 이게 다 무슨 뜻인가요?

즉, 코드 한 줄도 작성하지 않고도 Sails를 통해 Socket.io에 매핑된 완전한 RESTfull API가 있다는 뜻입니다!

하지만 소켓이 Ajax 요청보다 데이터 검색에 더 나은 이유는 무엇입니까? 더 효율적인 프로토콜일 뿐만 아니라 양방향 통신을 위해 소켓이 열려 있고 Sails는 이미 이를 활용하고 있습니다. Sails는 귀하에게 데이터를 전달할 뿐만 아니라 해당 데이터베이스에 대한 업데이트를 자동으로 구독하므로 무언가가 추가, 제거 또는 업데이트될 때마다 웹 소켓을 통해 클라이언트에 알림이 전송됩니다.

이것이 Sails가 위대한 이유입니다!

---

帆+骨干

我想讨论的下一个主题是 Backbone 集成，因为如果您不使用 JavaScript 框架，那么您就做错了。

考虑到这一点，Sails 和 Backbone 是完美的组合。 Backbone 与 Sails 一样，非常不显眼，它的所有功能都是可用的，能够被覆盖，并且是可选的。

如果您之前使用过 Backbone，您可能知道它与 REST API 本地连接，因此开箱即用，您可以将前端上的数据与 Sails 应用程序同步。

但是现在已经说得够多了，让我们通过创建一个基本的聊天应用程序来看看所有这一切的实际情况。首先，打开终端窗口并输入：

sails new ChatApp
cd ChatApp
sails generate model users
sails generate model messages
sails generate controller messages
sails generate controller main

这将为我们创建一个新应用程序并生成一些文件。从上面您可以看到，您可以生成两种不同的资源；模型和控制器。如果您熟悉 MVC 设计模式，那么您应该知道它们是什么，但简而言之，模型是您的数据，控制器保存您的逻辑代码。因此，我们需要两个集合，一个用于保存用户，另一个用于保存消息。

接下来，对于控制器，我们需要一个来处理页面路由，我将其命名为“main”，然后我们有第二个控制器，名为“messages”。现在你可能想知道为什么我创建了一个与我们的 messages 模型同名的控制器？好吧，如果您还记得的话，我说过 Sails 可以为您创建 REST API。发生的情况是，通过创建与模型同名的空白控制器，Sails 将知道回退并为相应的资源构建 REST API。

因此，我们已经为 messages 模型创建了一个控制器，但不需要为 users 模型创建一个控制器，所以我将其省略。这就是创建模型和控制器的全部内容。

接下来，让我们设置一些路线。

路线

路由始终是一个安全的起点，因为您通常很清楚要创建哪些页面。

所以打开 config 文件夹中的 routes.js 文件，一开始可能看起来有点不知所措，但是如果你删除所有注释并在以下路由中添加留下这样的东西：

module.exports.routes = {
    '/' : {
         controller: 'main',
         action: 'index'
    },
    '/signup' : {
         controller: 'main',
         action: 'signup'
    },
    '/login' : {
         controller: 'main',
         action: 'login'
    },
    '/chat' : {
         controller: 'main',
         action: 'chat'
    }
};

我们有一个主页、一个聊天页面，以及两个用于处理登录和注册页面的页面。我将它们全部放在同一个控制器中，但在 Sails 中，您可以创建任意数量的控制器。

型号

接下来，我们看一下生成的 messages 模型，该模型位于“api > models > Messages.js”。我们需要将必要的列添加到我们的模型中。现在这不是绝对必要的，但它会为我们创建一些我们可以使用的辅助函数：

//Messages Model  
module.exports = {
    attributes  : {
        userId: 'INT',
        username: 'STRING',
        message: 'STRING'      
    }
};

对于 messages 模型，我们从该消息所属用户的 id 开始，一个 username 这样我们就不必单独查询它，然后是实际的 message。

现在让我们填写用户的模型：

//Users Model 
module.exports = {
    attributes  : {
         username: 'STRING',
         password: 'STRING'      
    }
};

就是这样，我们只有 username 和 password 属性。下一步是在 MainController 中创建路由函数。

控制器

因此，打开MainController，可以在“api>controllers>MainController.js”中找到它。让我们首先为上面定义的每个路由创建一个函数：

var MainController = {
    index: function (req, res) {
        
    },
    signup: function (req, res) {
        
    },
    login: function (req, res) {
        
    },
    chat: function (req, res) {
        
    }
};
module.exports = MainController;

如果您熟悉 Express，那么您会很高兴看到这些功能是标准的 Express 路线功能。它们接收两个变量，req 用于 HTTP 请求，res 用于创建响应。

遵循 MVC 模式，Sails 提供了渲染视图的功能。主页不需要任何特殊的东西，所以我们只渲染视图。

index: function (req, res) {
    res.view();
},

Sails 更倾向于约定优于配置，因此当您调用 res.view(); 时，Sails 将使用以下模式查找视图文件（默认情况下带有 .ejs 扩展名）： '视图 > 控制器名称 > 方法名称.ejs'。因此，对于此调用，它将搜索“views>main>index.ejs”。还值得注意的是，这些视图仅包含页面的视图特定部分。如果你看一下'views>layout.ejs'，你会在中间看到一个对 的调用，这是你的视图文件将被插入的地方。默认情况下，它使用“layout.ejs”文件，但您只需将布局名称传递到名为“layout”的属性下的 res.view() 函数即可使用其他布局文件。例如： 'res.view( { layout: "other.ejs" } );'。

我将使用默认布局文件并进行一些小调整，我将添加 jQuery、Backbone 和 Underscore。因此，在 'layout.ejs' 文件中，在关闭 标记之前，添加以下行：

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.4.4/underscore-min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/backbone.js/1.0.0/backbone-min.js"></script>

完成后，我们现在就可以创建主页了。

主页

让我们在 views 文件夹中创建一个名为 main 的新文件夹，并在新的 main 文件夹中创建一个名为“index.ejs”的新文件。

在文件中，我们只创建一个登录和注册表单：

<h1>Code Chat</h1>
<div>
    <h3>Login</h3>
    <input type="text" id="loginName" placeholder="name" />
    <input type="password" id="loginPassword" placeholder="password" />
    <button id="loginButton">Login</button>
</div>
<div>
    <h3>Signup</h3>
    <input type="text" id="signupName" placeholder="name" />
    <input type="password" id="signupPassword" placeholder="password" />
    <input type="password" id="signupConfirmPassword" placeholder="confirm password" />
    <button id="signupButton">Signup</button>
</div>

非常简单，只是要点。

登录和注册区域

接下来我们需要添加一些 JS 来与服务器进行通信。现在这不是 Sails 特有的，我们只是通过 jQuery 向 Sails 服务器发送 AJAX 请求。

此代码可以包含在页面本身中，也可以通过单独的 JS 文件加载。为了方便起见，我将其放在同一页面的底部：

<script>
    $("#loginButton").click(function(){
        var username = $("#loginName").val();
        var password = $("#loginPassword").val();
        if (username && password) {
            $.post(
                '/login',
                {username: username, password:password},
                function () {
                    window.location = "/chat";
                }
            ).fail(function(res){
                alert("Error: " + res.getResponseHeader("error"));
            });
        } else {
            alert("A username and password is required");
        }
    });
</script>

这只是标准的 JS 和 jQuery，我们正在监听登录按钮上的单击事件，确保填写用户名和密码字段，并将数据发布到 '/login' 路由。如果登录成功，我们将用户重定向到聊天页面，否则将显示服务器返回的错误。

接下来，让我们为注册区域创建相同的内容：

$("#signupButton").click(function(){
    var username = $("#signupName").val();
    var password = $("#signupPassword").val();
    var confirmPassword = $("#signupConfirmPassword").val();
    if (username && password) {
        if (password === confirmPassword) {
            $.post(
                '/signup',
                {username: username, password:password},
                function () {
                    window.location = "/chat";
                }
            ).fail(function(res){
                alert("Error: " + res.getResponseHeader("error"));
            });
        } else {
            alert("Passwords don't match");
        }   
    } else {
        alert("A username and password is required");
    }
});

这段代码几乎是相同的，以至于您可以将整个 Ajax 部分抽象为它自己的函数，但对于本教程来说这很好。

现在我们需要返回到“MainController”并处理这两个路由，但在此之前，我想安装一个 Node 模块。我们需要对密码进行哈希处理，因为纯文本密码不是一件好事，甚至不利于演示！我发现了一个不错的模块，名为“password-hash”，由 David Wood 编写，效果很好。

要安装它，只需在终端中转到 Sails 应用程序的根目录并输入：npm install password-hash。

安装完成后，让我们打开 MainController 并实现两个所需的路由。让我们从 signup 开始：

signup: function (req, res) {
        var username = req.param("username");
        var password = req.param("password");
        
        Users.findByUsername(username).done(function(err, usr){
            if (err) {
                res.send(500, { error: "DB Error" });
            } else if (usr) {
                res.send(400, {error: "Username already Taken"});
            } else {
                var hasher = require("password-hash");
                password = hasher.generate(password);
                
                Users.create({username: username, password: password}).done(function(error, user) {
                if (error) {
                    res.send(500, {error: "DB Error"});
                } else {
                    req.session.user = user;
                    res.send(user);
                }
            });
        }
    });
}

这有点冗长，但我们在这里所做的只是从 POST 请求中读取用户名和密码，并确保用户名尚未被占用。你可以看到我也在使用我们刚刚安装的密码哈希器，它使用起来非常简单，只需将密码传递到生成方法中，它就会使用随机盐对其进行哈希处理。

还值得一提的是，在我们可能遇到错误或问题的每个可能位置，我们都会发回 HTTP 错误代码并通过名为“error”的自定义标头返回消息，如果您请记住，我们正在索引页上的警报消息中显示。

另一个值得注意的点是，我们使用了一个名为“findByUsername”的“神奇”函数，这是因为我们的用户模型中有一个 username 列。

最后，在底部您可以看到是否一切顺利，我们将用户存储在会话变量中，并以默认状态代码 200 返回它，这将告诉 jQuery AJAX 请求已成功。

接下来我们来编写登录函数：

login: function (req, res) {
    var username = req.param("username");
    var password = req.param("password");
    
    Users.findByUsername(username).done(function(err, usr) {
        if (err) {
            res.send(500, { error: "DB Error" });
        } else {
            if (usr) {
                var hasher = require("password-hash");
                if (hasher.verify(password, usr.password)) {
                    req.session.user = usr;
                    res.send(usr);
                } else {
                    res.send(400, { error: "Wrong Password" });
                }
            } else {
                res.send(404, { error: "User not Found" });
            }
        }
    });
}

同样，这与之前的 signup 函数非常相似，我们正在搜索与从表单中发布的用户名相同的用户，如果找到，我们使用哈希器的 验证方法。我们不能再次对密码进行哈希处理并将其传递到模型 find 函数的原因是因为哈希器使用随机盐，因此如果我们再次对密码进行哈希处理，它将等于其他内容。

其余代码相同；如果一切正常，我们将用户存储在会话中并返回它，否则我们会发回一条错误消息。

登录系统现已完成，我们终于可以继续构建聊天功能了。

构建聊天功能

由于我们将使用 Backbone 来获取消息，因此实际的路由功能将非常简单。这是完整的聊天功能：

chat: function (req, res) {
    if (req.session.user) {
        res.view({username: req.session.user.username});
    } else {
        res.redirect('/');
    }
}

我们首先检查用户是否登录，如果检查成功，那么它将加载视图，并将会话中的用户名传递给它，否则我们只是重定向到主页。 p>

现在让我们在 main 文件夹中创建一个名为“chat.ejs”的新视图。打开它，让我们创建一个简单的表单来发布新消息，并创建一个 div 容器来显示所有消息。

<h2>Welcome <%= username %></h2>
<div id="newMessageForm">
    <textarea id="message" placeholder="Enter your message here:"></textarea>
    <button id="postMessageButton">Add Message</button>
</div>
<div id="messagesContainer">
</div>

对于这个视图，我们只使用了一些非常标准的 HTML。唯一可能需要解释的是 代码，这种编码风格并不是 Sails 特有的，它实际上是 EJS 的语法。这种语法与 PHP 的短标签非常相似。 相当于 PHP 中的 <code>， 与 <code>= 相同。 EJS 的第一个片段允许您在页面上集成标准 JS 代码，而第二个片段则打印出其中的代码。这里我们只是打印出从控制器传入的用户名。

我们的聊天功能的其余部分将全部由 JavaScript 实现。首先，让我们看看如何使用标准 Backbone 编写聊天功能，然后我们将了解如何利用网络套接字。

在页面底部添加以下JS：

<script>
    var MessageModel = Backbone.Model.extend({
        urlRoot: '/messages',
    });

    var MessageCollection = Backbone.Collection.extend({
        url: '/messages',
        model: MessageModel,
    });

    var messages = new MessageCollection();
    messages.fetch();

    $("#postMessageButton").click(function(){
        var messageText = $("#message").val();
        messages.create({message: messageText}, {wait: true});
        $("#message").val("");
    });
</script>

由于 Sails 自动创建 Backbone 本身可以理解的 API，因此无需编写额外的服务器代码，因此没有比这更容易的了。这就是我在说 Sails 不是为了成为一个“框架”时所谈论的内容。它不会试图让您使用自己的语法，它是为了完成任务而设计的，正如您所看到的，它提供了。

要对其进行测试，请打开终端窗口并导航到 Sails 应用程序文件夹，然后输入“sails lift”以启动它。默认情况下，它将启动到 http://localhost:1337。现在只需注册并发布一些消息即可。

要查看您发布的消息，您可以 console.log messages 变量，或者在浏览器控制台中查看它。现在我们接下来应该实现一个视图，以便我们可以在浏览器中看到发布的消息。

_.templateSettings = {
    interpolate : /\{\{(.+?)\}\}/g
};
var MessagesView = Backbone.View.extend({
    el: '#messagesContainer',
    initialize: function () {
        this.collection.on('add', this.render, this);
        this.render();
    },
    template: _.template("<div><p>{{ message }}</p></div>"),
        render: function () {
            this.$el.html("");
            this.collection.each(function(msg){
                this.$el.append(this.template(msg.toJSON()));
            }, this)
    }
});

var mView = new MessagesView({collection: messages});

我们首先定义一个视图，将其附加到我们之前创建的 div，然后在集合上添加一个事件处理程序，以便在每次将新模型添加到集合时重新渲染 div。

您可以在顶部看到，我必须将默认的下划线设置从使用模板内部的 EJS 语法更改为使用 Mustache 的语法。这是因为该页面已经是一个 EJS 文档，因此它将在服务器上处理，而不是在 Underscore 中处理。

注意：我没有为此想出正则表达式，这归功于 Underscore 文档本身。

最后，在底部您可以看到我们创建了该视图的一个新实例，并向其传递了集合变量。

如果一切顺利，您现在应该在浏览器中看到您的消息，并且每当您创建新帖子时它都会更新。

---

航行政策

现在您可能已经注意到，我们在提交帖子时没有设置 userId 或 username，这是出于安全目的。

您不想将这种控制放在客户端。如果某人所要做的就是修改 JavaScript 变量来控制另一个用户的帐户，那么您将遇到一个大问题。

那么，你应该如何处理这个问题呢？嗯，当然有政策。

策略基本上是中间件，在实际 Web 请求之前运行，您可以根据需要在其中停止、修改甚至重定向请求。

对于此应用，让我们为我们的消息创建一个策略。策略应用于控制器，因此它们甚至可以在普通页面上运行，但在本教程中，我们只为 messages 模型使用一个策略。

在“api>policies”文件夹中创建一个名为“MessagesPolicy.js”的文件，并输入以下内容：

module.exports = function (req, res, next) {
    if (req.session.user) {
        var action = req.param('action');
        if (action == "create") {
            req.body.userId = req.session.user.id;
            req.body.username = req.session.user.username;
        }
        next();
    } else {
        res.send("You Must Be Logged In", 403);
    }
};

那么，这是怎么回事？您可以看到该函数类似于普通的路由函数，但区别在于第三个参数，它将调用堆栈中的下一个中间件。如果您对中间件的概念不熟悉，您可以将其想象为俄罗斯嵌套娃娃。每一层都会收到请求以及响应变量，并且可以根据需要对其进行修改。如果满足了所有的要求，该层就可以进一步传入，直到到达中心，这就是路由函数。

所以我们在这里检查用户是否已登录，如果用户未登录，我们将显示 403 错误并且请求在此结束。否则，（即用户已登录）我们调用 next(); 来传递它。在上面代码的中间，是我们注入一些后置变量的地方。我们将此应用于“消息”控制器（基本上是 API）上的所有调用，因此我们获取操作并检查此请求是否正在尝试创建新消息，在这种情况下，我们为用户的 id 和 用户名。

接下来，打开config文件夹中的policies.js文件，并添加我们刚刚创建的策略。所以你的文件应该是这样的：

module.exports.policies = { 
    '*': true,
    'messages': 'MessagesPolicy'
};

完成此操作后，我们需要删除所有旧记录，因为它们没有这些新信息。因此，关闭 Sails 服务器 (ctrl-c) 并在同一终端窗口中输入： rm -r .tmp 以删除临时数据库，让我们重新开始。

接下来，让我们将用户名添加到实际帖子中，因此在“chat.ejs”中将模板更改为：

template: _.template("<div><p><b>{{ username }}: </b>{{ message }}</p></div>"),

重新启动 Sails 服务器（再次使用 sails lift）并注册另一个新用户来测试它。如果一切正常，您应该能够添加消息并在帖子中看到您的名字。

此时我们已经有了一个非常好的设置，我们使用 Backbone 和 API 自动获取帖子，此外我们还有一些基本的安全措施。问题是，当其他人发布消息时它不会更新。现在，您可以通过创建 JavaScript 间隔并轮询更新来解决此问题，但我们可以做得更好。

利用 Websocket

我之前提到过，Sails 利用 websockets 的双向功能来发布订阅数据的更新。使用这些更新，我们可以侦听消息表中的新添加内容并相应地更新集合。

因此，在 chat.ejs 文件中，让我们创建一种新的集合； SailsCollection：

var SailsCollection = Backbone.Collection.extend({
    sailsCollection: "",
    socket: null,
    sync: function(method, model, options){
        var where = {};
        if (options.where) {
            where = {
                where: options.where
            }
        }       
        if(typeof this.sailsCollection === "string" && this.sailsCollection !== "") {
            this.socket = io.connect();
            this.socket.on("connect", _.bind(function(){
                this.socket.request("/" + this.sailsCollection, where, _.bind(function(users){
                    this.set(users);
                }, this));
    
                this.socket.on("message", _.bind(function(msg){
                    var m = msg.uri.split("/").pop();
                    if (m === "create") {
                        this.add(msg.data);
                    } else if (m === "update") {
                        this.get(msg.data.id).set(msg.data);
                    } else if (m === "destroy") {
                        this.remove(this.get(msg.data.id));
                    }
                }, this));
            }, this));
        } else {
            console.log("Error: Cannot retrieve models because property 'sailsCollection' not set on the collection");
        }
    }
});

现在可能很长，但实际上很简单，让我们来看看。我们首先向 Collection 对象添加两个新属性，一个用于保存 Sails“模型”的名称，另一个用于保存 Web 套接字。接下来我们修改sync函数，如果你熟悉Backbone，那么你就会知道，当你调用fetch等函数时，这个函数就是与服务器接口的函数。通常，它会触发 Ajax 请求，但我们将对其进行自定义以进行套接字通信。

现在，我们没有使用 sync 函数提供的大部分功能，主要是因为我们没有添加用户更新或删除消息的功能，但为了完整起见，我将它们包含在函数定义。

我们来看看sync函数的第一部分：

var where = {};
if (options.where) {
    where = {
        where: options.where
    }
}

此代码首先检查是否发送了任何“where”子句，这将允许您执行以下操作： messages.fetch({ where : { id: 4 } }); 仅获取其中的行id 等于 4。

之后，我们有一些代码来确保已设置 'sailsCollection' 属性，否则我们会记录一条错误消息。然后，我们创建一个新的套接字并连接到服务器，通过 on('connect') 事件监听连接。

连接后，我们请求指定的“sailsCollection”索引以拉入当前模型列表。当它接收到数据时，我们使用集合的 set 函数来初始设置模型。

好吧，到目前为止，我们已经有了相当于标准 fetch 命令的命令。下一个代码块是推送通知发生的地方：

this.socket.on("message", _.bind(function(msg){
    var m = msg.uri.split("/").pop();
    if (m === "create") {
        this.add(msg.data);
    } else if (m === "update") {
        this.get(msg.data.id).set(msg.data);
    } else if (m === "destroy") {
        this.remove(this.get(msg.data.id));
    }
}, this));

现在正在执行的操作（无论是创建、更新还是销毁消息）都可以在实际的 msg 内部找到，然后该操作又在 uri 内部。为了获取操作，我们用正斜杠（“/”）分割 URI，并使用 pop 函数仅获取最后一段。然后，我们尝试将其与 create、update 或 destroy 三个可能的操作相匹配。

剩下的就是标准的Backbone，我们可以添加、编辑或删除指定的模型。随着我们的新类即将完成，剩下要做的就是更改当前的 MessageCollection。它需要扩展我们的新集合，而不是扩展 Backbone 集合，如下所示：

var MessageCollection = SailsCollection.extend({
    sailsCollection: 'messages',
    model: MessageModel
});

除了扩展我们的新集合之外，我们还将进行另一项更改，以便我们现在设置 sailsCollection 属性，而不是设置 URL 属性。这就是全部内容。在两个不同的浏览器（例如 Chrome 和 Safari）中打开应用程序并注册两个单独的用户。您应该看到从任一浏览器发布的消息都会立即显示在另一个浏览器上，无需轮询，没有麻烦。

---

结论

Sails 是在杂乱的框架中呼吸的新鲜空气。它在门口检查自己的自我，并尽其所能帮助开发商而不是品牌。我一直在与 Sails 开发人员聊天，我可以告诉您，还有更多令人惊叹的作品正在开发中，看看这个框架的发展方向将会很有趣。

总之，您已经了解了如何在 Sails 中设置、使用和保护数据，以及如何将其与流行的 Backbone 库连接。

与往常一样，如果您有任何意见，请随时在下面留言，或加入我们的 Nettuts+ IRC 频道（freenode 上的“#nettuts”）。感谢您的阅读。

위 내용은 Sails.js를 사용하여 데이터 처리의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!