小编dgh*_*dgh的帖子

我有一个以JSON格式存储许多JavaScript对象的文件,我需要读取文件,创建每个对象,并对它们做一些事情(在我的情况下将它们插入到数据库中).JavaScript对象可以表示为一种格式:

格式A:

[{name: 'thing1'},
....
{name: 'thing999999999'}]

或格式B:

{name: 'thing1'}         // <== My choice.
...
{name: 'thing999999999'}

请注意,它...表示许多JSON对象.我知道我可以将整个文件读入内存然后JSON.parse()像这样使用:

fs.readFile(filePath, 'utf-8', function (err, fileContents) {
  if (err) throw err;
  console.log(JSON.parse(fileContents));
});

但是,文件可能非常大,我宁愿使用流来完成此任务.我在流中看到的问题是文件内容可能在任何时候都被分成数据块,所以如何JSON.parse()在这些对象上使用？

理想情况下,每个对象都将被视为一个单独的数据块,但我不知道如何做到这一点.

var importStream = fs.createReadStream(filePath, {flags: 'r', encoding: 'utf-8'});
importStream.on('data', function(chunk) {

    var pleaseBeAJSObject = JSON.parse(chunk);           
    // insert pleaseBeAJSObject in a database
});
importStream.on('end', function(item) {
   console.log("Woot, imported objects into the database!");
});*/

注意,我希望防止将整个文件读入内存.时间效率对我来说无关紧要.是的,我可以尝试一次读取多个对象并立即将它们全部插入,但这是性能调整 - 我需要一种保证不会导致内存过载的方法,无论文件中包含多少个对象.

我可以选择使用FormatA或者使用FormatB …

我在Python Web环境中工作,我只需使用boto的key.set_contents_from_filename(path/to/file)将文件从文件系统上传到S3.但是,我想上传一张已在网络上的图片(比如https://pbs.twimg.com/media/A9h_htACIAAaCf6.jpg:large).

我应该以某种方式将图像下载到文件系统,然后像往常一样使用boto将其上传到S3,然后删除图像？

什么是理想的是,如果有一种方法可以获得boto的key.set_contents_from_file或其他一些接受URL的命令,并将图像很好地流式传输到S3,而不必明确地将文件副本下载到我的服务器.

def upload(url):
    try:
        conn = boto.connect_s3(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY)
        bucket_name = settings.AWS_STORAGE_BUCKET_NAME
        bucket = conn.get_bucket(bucket_name)
        k = Key(bucket)
        k.key = "test"
        k.set_contents_from_file(url)
        k.make_public()
                return "Success?"
    except Exception, e:
            return e

使用set_contents_from_file,如上所述,我得到一个"字符串对象没有属性'tell'"错误.将set_contents_from_filename与url一起使用,我得到No No file或目录错误.该博托存储文档的上传本地文件叶关闭,并没有提及上传远程存储的文件.

我的具体问题是我需要执行(可能)大量的Javascript函数来准备像批处理文件(每个函数调用将一些信息添加到同一个批处理文件),然后,在完成所有这些调用之后,执行一个发送批处理文件的最终函数(例如,将其作为HTML响应发送).我正在寻找一个通用的Javascript编程模式.

概括问题:鉴于Javascript函数funcA(),funcB()和funcC(),我想找出订购执行的最佳方法,这样funcC只能在执行funcA和funcB之后执行.我知道我可以使用这样的嵌套回调函数:

funcA = function() {
    //Does funcA stuff
    funcB();
}
funcB = function() {
    //Does funcB stuff
    funcC();
}

funcA();

我甚至可以通过传递回调参数使这个模式更加通用,但是,这个解决方案变得非常冗长.

我也熟悉Javascript函数链接,解决方案可能如下所示:

myObj = {}
myObj.answer = ""
myObj.funcA = function() {
    //Do some work on this.answer
    return this;
}
myObj.funcB = function() {
    //Do some more work on this.answer
    return this;
}
myObj.funcC = function() {
    //Use the value of this.answer now that funcA and funcB have made their modifications
    return this;
}
myObj.funcA().funcB().funcC();

虽然这个解决方案对我来说似乎有点清晰,但随着您向计算添加更多步骤,功能执行链变得越来越长.

对于我的具体问题,执行funcA,funcB等的顺序无关紧要.因此,在上面的解决方案中,我在技术上做了比工作要求更多的工作,因为我将所有功能放在一个串行排序中.对我来说最重要的是funcC(用于发送结果或触发请求的某些函数)仅在funcA和funcB完成所有执行后调用.理想情况下,funcC可以某种方式监听所有中间函数调用完成,然后执行？我希望学习一般的Javascript模式来解决这样的问题.

谢谢你的帮助.

另一个想法:也许将共享对象传递给funcA和funcB,当它们完成执行时,标记共享对象,如sharedThing.funcA …

我目前有一个带有'title'和'summary'字段的Post模型.我正在检索所有帖子并将它们作为JSON作为RESTful API接口的一部分返回.

这是基本方法

from django.core import serializers

def list_posts(request):
    posts = Post.objects.filter(owner=authenticated_user)
    serialized = serializers.serialize("json", posts, fields=('title', 'summary'))
    return HttpResponse(serialized, mimetype='application/json')

当我访问相应的路线时,我得到以下回复.

目前的回应

[{"pk": 4, "model": "api.post", "fields": {"summary": "Testing", "title": "My Test"}}, {"pk": 5, "model": "api.post", "fields": {"summary": "testing again", "title": "Another test"}}]

这在技术上包含了我的客户端构建模型所需的所有信息(我使用Backbone并且可以使用collection.parse构建我需要的东西,但是服务器端应该负责很好地构建响应).让我感到困扰的是,它看起来不像我以前在信誉良好的API中看到的标准API响应.我认为像下面这样的JSON响应会更"标准".

期望的回应

[{'summary': 'Testing', 'id': 4, 'title': 'My test'}, {'summary': 'My Test', 'id':5, 'title': 'Another test'}]

serialize的输出似乎不适合将JSON中的模型实例集合作为API调用的响应返回,这似乎是一个相当普遍的需求.我想返回字段信息以及id(或pk,如果它必须被称为pk).

Go net/rpc库文档允许通过原始网络连接或HTTP通过网络公开对象.

HTTP示例

arith := new(Arith)
rpc.Register(arith)
rpc.HandleHTTP()
l, e := net.Listen("tcp", ":1234")
if e != nil {
    log.Fatal("listen error:", e)
}
go http.Serve(l, nil)

原始TCP网络连接

arith := new(Arith)
rpc.Register(arith)
l, e := net.Listen("tcp", ":1234")
if e != nil {
    log.Fatal("listen error:", e)
}
go func() {
    for {
        conn, err := l.Accept()
        go rpc.ServeConn(conn)
    } 
}

要调用第一种类型的服务器,可以使用rpc.DialHTTP("tcp","127.0.0.1:1234"),对于第二种类型,rpc.Dial("tcp","127.0.0.1:1234")将使用用过的.

我的问题是这两者有何不同？运行HTTP服务器与"原始网络连接"服务器有什么优缺点？可以通过curl或浏览器以某种方式使用HTTP执行RPC吗？HTTP版本对跨语言RPC调用有用吗？

我正在尝试编写一个用于设置用户的小文件夹文件,并将当前用户作为一个小例子来向我自己证明它正在工作.我尝试了很多变种,在文档中找不到太多帮助.

FROM ubuntu
USER daemon
# ENTRYPOINT ["echo", "$USER"]
# just gives "$USER"
# ENTRYPOINT ["echo", "-e", "${USER}"]
# just gives "$USER"
# ENTRYPOINT echo $USER
# gives empty string
# ENTRYPOINT ["/bin/echo", "$USER"]
# just gives "$USER"

我正在运行docker build .dockerfile,然后运行docker run <image-id>并获得结果

我期望预期的结果是daemon,或没有USER daemon线root.可能是一个非常简单的答案.

我正在编写客户端代码,并希望编写多个可以交互的模块化JS文件,同时防止全局命名空间污染.

的index.html

<script src="util.js"></script>
<script src="index.js"></script>

util.js中

(function() {
    var helper() {
        // Performs some useful utility operation
    }
});

index.js

(function () {
    console.log("Loaded index.js script");
    helper();
    console.log("Done with execution.");
})

此代码很好地将实用程序函数保存在单独的文件中,并且不会污染全局命名空间.但是,不会执行辅助实用程序函数,因为'helper'存在于单独的匿名函数名称空间中.

一种替代方法涉及将所有JS代码放在一个文件中或在全局命名空间中使用单个变量,如下所示:

var util_ns = {
    helper: function() {
        // Performs some useful utility operation.        
    },
    etc.
}

这两种方法在模块化和干净的命名空间方面都有缺点.

我习惯在Node.js中工作(服务器端),我可以在另一个内部"需要"一个Javascript文件,有效地将util.js绑定注入index.js命名空间.

我想在这里做类似的事情(但是客户端),允许代码在单独的模块化文件中编写,而不在全局命名空间中创建任何变量,同时允许访问其他模块(例如实用程序模块).

这是否可以通过简单的方式实现(没有库等)？

如果没有,在使客户端JS的行为更像Node和npm的领域,我知道requireJS,browserify,AMD和commonJS标准化尝试的存在.但是,我不确定每个的优缺点和实际用法.

我有一个特定的Go lang结构对象,我正在与之交互,我希望它与自己相等.我将函数传递给一个只返回它的函数,但是通过接受接口{}输入/输出来实现它

type Animal struct {
    name string
    food interface{}
}

type YummyFood {
    calories int
}

func echo_back(input interface{}) interface{} {
    return input
}

func main() {
    var tiger_food = Food{calories: 1000}
    var tiger = Animal{name: "Larry", food: tiger_food}
    output_tiger := echo_back(tiger)

    fmt.Printf("%T, %+v\n", tiger, tiger)
    fmt.Printf("%T, %+v\n", output_tiger, output_tiger)
    fmt.Println(tiger == output_tiger)
    fmt.Println(tiger == output_tiger.(Animal))

}

运行它,您会看到tiger和output_tiger看起来是相同的并且评估为相等.大.这就是我所期待的.现在,尝试使用YummyFood的这个定义

type YummyFood {
    calories int
    ingredients []string
}

突然之间,即使使用类型断言,echo_back的输出也不会评估为与输入相同.我得到'恐慌:运行时错误:比较无法比较的类型YummyFood'

问题是为什么添加[]字符串类型会导致输入和输出无法比较？如何修改output_tiger以取回我放入的相同内容(即我希望它与'tiger'相同).我如何反映output_tiger使它等于老虎？

我想配置我的Octopress博客,在所有页面的head元素中添加作者链接,以便我的Google+图片显示在我的博客帖子的搜索结果旁边.目前,我相信我可以包括一个

<link rel ="author"href ="url/to/google/plus/profile">

在每个帖子中,但这很乏味.由于我博客上的每篇文章都是由我撰写的,我希望上面的链接只显示在我博客的每个Octopress页面的标题中.然后在Google+上我可以将我的博客列为我所贡献的网站,而不是列出我为每篇文章做出的贡献.

我是谷歌作者的新手,所以也许我想做的不是最好的方法.我的总体目标只是让我的Google plus照片显示在我在Google搜索结果和Google+上的所有Octopress博客文章旁边,只列出我作为我贡献的网站的博客(而不是每篇文章).

class Geolocation(db.Model):
    __tablename__ = "geolocation"
    id = db.Column(db.Integer, primary_key=True)
    latitude = db.Column(db.Float)
    longitude = db.Column(db.Float)
    elevation = db.Column(db.Float)         # Meters
    # Relationships
    pin = db.relationship('Pin', uselist=False, backref="geolocation")

    def __init__(self, latitude, longitude, elevation):
        self.latitude = latitude
        self.longitude = longitude
        self.elevation = elevation

    def __repr__(self):
        return '<Geolocation %s, %s>' % (self.latitude, self.longitude)


class Pin(db.Model):
    __tablename__ = "pin"
    id = db.Column(db.Integer, primary_key=True)
    geolocation_id = db.Column(db.Integer, db.ForeignKey('geolocation.id'))  # True one to one relationship (Implicit child)

    def __init__(self, geolocation_id):
        self.geolocation_id = geolocation_id

    def __repr__(self):
        return …

阅读了有关Google数据存储区的概念/理论后，我开始使用Go数据存储区包

场景：种类User和LinkedAccount要求每个用户都有一个或多个关联账户（耶第三方登录）。为了保持高度一致性，LinkedAccounts将是关联用户的子级。然后，创建新用户涉及创建一个User和一个LinkedAccount，而不仅仅是一个。

用户创建似乎是交易的完美用例。如果说LinkedAccount创建失败，则事务回滚失败。目前看来这不可能。目标是在事务中创建父级，然后创建子级。

根据文档

如果事务是单个组事务，则事务中的所有数据存储区操作必须在同一实体组中的实体上进行操作

我们希望有一个新的User并且LinkedAccount要在同一个组中，所以对我来说，Datastore应该支持这种情况。我担心的是预期的含义是可以在单个事务中执行对同一组中现有实体的操作。

tx, err := datastore.NewTransaction(ctx)
if err != nil {
    return err
}
incompleteUserKey := datastore.NewIncompleteKey(ctx, "User", nil)
pendingKey, err := tx.Put(incompleteUserKey, user)
if err != nil {
    return err
}
incompleteLinkedAccountKey := datastore.NewIncompleteKey(ctx, "GithubAccount", incompleteUserKey)
// also tried PendingKey as parent, but its a separate struct type
_, err = tx.Put(incompleteLinkedAccountKey, linkedAccount)
if err != nil {
    return err
}
// attempt to …

我有Django设置来收集我的静态文件并使用django-storage将它们复制到S3中,当我明确地运行时,这就像一个魅力

heroku run python manage.py collectstatic

但是,我希望Heroku在部署时自动执行此操作(即git push to Heroku),如本文档https://devcenter.heroku.com/articles/django-assets中所述.显然,输出:

python manage.py collectstatic --dry-run --noinput

确定是否正确配置了collectstatic(当我明确地运行它时,collectstatic正常工作).我明白了:

$ heroku run python manage.py collectstatic --dry-run --noinput
Running `python manage.py collectstatic --dry-run --noinput` attached to terminal... up, run.9607
Pretending to copy '/app/app_pkg/static/robots.txt'
.... # Lot of similar outputs not shown
16 static files copied.

这看起来不错,但文档没有说明我应该看到的内容.当我部署项目时,一切似乎都运行良好并成功完成.

-----> Installing dependencies using Pip (1.2.1)
       Cleaning up...
-----> Collecting static files
       16 static files copied.

-----> Discovering process types
       Procfile declares types -> …