小编Mar*_*yer的帖子

Knex的交易文档包含如下代码：

knex.transaction(function(trx) {
    var books = [
        {title: 'Canterbury Tales'},
        {title: 'Moby Dick'},
        {title: 'Hamlet'}
    ];

    return trx
    .insert({name: 'Old Books'}, 'id')
    .into('catalogues')
    .then(function(ids) {
    return Promise.map(books, function(book) {
        book.catalogue_id = ids[0];

        // Some validation could take place here.

        return trx.insert(info).into('books');
    });
    });
})

在SO上，我看到了广泛使用函数transacting()的示例，如下所示：

knex.transaction(function(trx) {
   knex('foo')
  .transacting(trx)
  .insert({id:"bar", username:"bar"})
  // etc
 })

Knex transacting()用类似于上面的示例描述：

knex.transaction使用该事务处理方法，它可以链接到任何查询，并传递您希望加入该查询的对象作为事务的一部分。

我的问题是：

是什么区别trx.insert().into('foo')和knex('foo').transacting(trx).insert()你为什么要使用一个，而不是其他？

我log在Postgres数据库中有一个简单的表,看起来像这样(示例简化):

time::timestamptz
action::varchar

time                          | action
2017-10-16 17:14:49.473903-08 | 'some action'
2017-10-16 17:14:49.473903-08 | 'some other action'
2017-10-17 17:14:49.473903-08 | 'some action'
//etc.

有各种各样的行动.我想查询此表以获得每天一行,其中包含每个操作的计数数组.这是我想要的结果:

day            actions
'2017-10-08' | [{"action":"some action", "count":10}, 
             |  {"action":"some other action", "count":20}}]
'2017-10-09' | [{"action":"some action", "count":15}, 
             |  {"action":"some other action", "count":18}}]

我几乎可以用这个:

SELECT day, json_agg(act) as actions
FROM (
    SELECT action, time::date as day,  COUNT(*)
    FROM log_hits
    GROUP BY (action, day)
) act
GROUP BY day

当然,这会导致在actions数组中的每个对象中发生日期...

day           actions
'2017-10-08' | [{"action":"some action", …

我试图从JSON对象中获取key的特定数组值,并将其存储在一个类似于此的数组中.

例:

var obj = { "1":{"class":2,"percent":0.99,"box":[0.2,0.3,0.4,0.5]},
            "2":{"class":2,"percent":0.99,"box":[0.12,0.23,0.45,0.56]},
            "3":{"class":2,"percent":0.99,"box":[0.52,0.83,0.34,0.59]}
           } 

等等

现在我需要获取键"box"的值并存储在数组中.

var list = []
list = [[0.2,0.3,0.4,0.5],[0.12,0.23,0.45,0.56],[0.52,0.83,0.34,0.59]]

但是,我尝试了多种方法将数组存储在数组中,但是当我打印列表时,我能够得到这样的结果

list = 0.2,0.3,0.4,0.5,0.12,0.23,0.45,0.56,0.52,0.83,0.34,0.59

我正在 freeCodeCamp 学习，目前正在学习基础算法。我正在做虚假保镖练习，您需要从数组中删除所有虚假值。遗憾的是，该任务只有高级答案，即使用 filter() 方法。我决定做一个基本的，但目前卡住了。

function bouncer(arr) { 

//*loops through array*    

for (let i = 0; i < arr.length; i++) {  

// *if there is a value that is falsy, delete that value from the array*    

if (arr[i] == 0 || arr[i] == NaN || arr[i] == null || arr[i] == false || arr[i] == "" || arr[i] == undefined) {        

delete arr[i];

     }    

   }    

return arr;

} 

console.log(bouncer([7, "ate", "", false, 9]));

它返回：

7、吃了、、、9。

该函数确实删除了虚假值，但我留下了这三个句点（，，，）。有没有办法让这个函数更正确地工作并返回没有这些句点的真值，同时又不失去函数的简单性？感谢你的帮助。

我对 JavaScript、Node 等仍然有些陌生，并且来自 Groovy 背景（其语法与 JavaScript 极其相似）。在 Groovy 中，我可以轻松地执行以下操作：

def myMap1 = {};
def myMap2 = {};

myMap1["key1"] = "value1";
myMap1["key2"] = "value2";
myMap1["key3"] = "value3";

myMap1.each() { key, value =>
    myMap2[key] = value;
}

这将遍历现有映射 (myMap1) 并将每个键的值复制到新映射 (myMap2)，并使用相同的键名。非常简单。然而，JS 有一个原型的概念，这让我很抓狂，因为你必须使用 hasOwnProperty、项目的索引等，这导致了大量代码用于一些本来应该非常简单的事情。

查看 Object() 的 MDN 文档，看起来 JS 已经实现了一些东西，允许开发人员访问键/值对，而无需处理原型设计和所有这些东西，您只需访问对象中的数据，而不是对象的属性。我现在有这个：

def myMap1 = {};
def myMap2 = {};

myMap1["key1"] = "value1";
myMap1["key2"] = "value2";
myMap1["key3"] = "value3";

myMap1.each() { key, value =>
    myMap2[key] = value;
}

我认为这会起作用，但我在控制台中得到了这个：

Old value is undefined
Setting …

我写下了代码来计算字符串中每个字符的计数。对于某些失败的单词，它似乎正常工作。

对于最后一个字符，它失败，因为我看到字符串的长度变得小于迭代计数（但对于某些单词）

var str1 = "america"

function noofchars(str1) {
  for (var m = 0; m < str1.length + 1; m++) {
    var countno = 1;
    if (m != 0) {
      str1 = str1.slice(1)
    }

    str2 = str1.substr(0, 1)

    for (var i = 0; i < str1.length; i++) {
      if (str2 === str1.charAt(i + 1)) {
        countno += 1
        str1 = str1.slice(0, i + 1) + str1.slice(i + 2) + " "
      }
    }
    console.log(str1.charAt(0) + "=" + countno)
  }
} …

我正在关注Angular 2上的一些教程，并尝试将一个简单的Typeahead组件组合在一起。它正在工作，但是我想添加一个选项，在键入最小长度的字符串之前，不要点击服务器。我可以通过在流中添加一个过滤器来做到这一点（但是），但是当我退格到最小值以下（或从输入中删除文本）时，我希望提前输入清除。目前，如果我输入最小长度和退格键，结果将保持不变。

我可以向其中添加* ngIf并进行表单验证，table但是这种感觉很不客气，我认为我应该能够以某种方式将空数组发送到模板。但是我找不到任何有效的方法。

这是我所拥有的精简版：

@Component({
    selector: 'typeahead',
    template: `
        <div>
            <input
                required
                type="text"
                placeholder="Person"
                #person [ngFormControl]="searchText">
        </div>
        <table>
            <tbody>
                <tr *ngFor="#person of people | async">
                <td> {{person.name}}</td>
                </tr>
            </tbody>
        </table>
        `,
    changeDetection: ChangeDetectionStrategy.OnPush,
})
export class TypeAhead {
    searchText = new Control(); 
    people: Observable<any[]>;

    constructor(db:DBService){
        this.people = this.searchText.valueChanges
        .debounceTime(200)
        .filter((val:string) => (val.length > 1))
        .switchMap((val:string) => db.searchNodes("Person", val))   
    }
}

我只需要一个从输入列表中删除零的函数

def no_zero(a):
    pos=0
    while (pos+1)<=len(a):
        if a[pos] == "0":
            a.remove[pos]
        pos= pos +1
    return a

print(no_zero([0,1,0,2,0,3]))

我应该得到1,2,3的输出，但是它会跳过正确的返回a。关于为什么的任何指示？干杯。

I am making a program that takes a text file that looks something like this:

1
0
1
1
1

and converts it into a list:

['1','0','1','1','1']

The file has 400 lines so I want to convert it into an array that's 20 columns by 20 rows.