web-dev-qa-db-fra.com

Comment accéder à un objet RowDataPacket

Je développe actuellement une application de bureau avec Node-webkit. Au cours de ce processus, je dois obtenir des données d’une base de données MySQL locale.

L'interrogation fonctionne bien, mais je ne vois pas comment accéder aux résultats. Je les stocke tous dans un tableau qui est ensuite passé à une fonction. Dans la console, ils ressemblent à ceci:

RowDataPacket {user_id: 101, ActionsPerformed: 20}
RowDataPacket {user_id: 102, ActionsPerformed: 110}
RowDataPacket {user_id: 104, ActionsPerformed: 3}

Et voici la structure de la requête:

var ret = [];
conn.query(SQLquery, function(err, rows, fields) {
    if (err)
        alert("...");
    else {
        for (var i of rows) 
            ret.Push(i);
    }
    doStuffwithTheResult(ret);
}

Comment puis-je récupérer cela dans la fonction doStuffwithTheResult? Les valeurs sont plus importantes, mais si je pouvais aussi obtenir les clés, ce serait formidable. 

mysqlnode.jsnode-webkit
34
paK0

Il s'avère que ce sont des objets normaux et vous pouvez y accéder via user_id.

Si le résultat est un tableau, vous devrez utiliser [0].user_id.

61
paK0

J'ai également rencontré le même problème récemment, lorsque j'utilise waterline dans un projet express pour des requêtes complexes, j'utilise l'instruction SQL pour interroger.

voici ma solution: commencez par transformer la valeur de retour (objet RowDataPacket) en chaîne, puis convertissez cette chaîne en objet json.

Ce qui suit est le code: 

//select all user (查询全部用户)
find: function(req, res, next){
    console.log("i am in user find list");
    var sql="select * from tb_user";

    req.models.tb_user.query(sql,function(err, results) {
        console.log('>> results: ', results );
        var string=JSON.stringify(results);
        console.log('>> string: ', string );
        var json =  JSON.parse(string);
        console.log('>> json: ', json);
        console.log('>> user.name: ', json[0].name);
        req.list = json;
        next();
    });
}

Ce qui suit est console: 

    >> results:  [ RowDataPacket {
    user_id: '2fc48bd0-a62c-11e5-9a32-a31e4e4cd6a5',
    name: 'wuwanyu',
    psw: '123',
    school: 'Northeastern university',                                                                                                                                           
    major: 'Communication engineering',                                                                                                                                            
    points: '10',
    datems: '1450514441486',
    createdAt: Sat Dec 19 2015 16:42:31 GMT+0800 (中国标准时间),                                                                                                  
    updatedAt: Sat Dec 19 2015 16:42:31 GMT+0800 (中国标准时间),                                                                                                  
    ID: 3,
    phone: 2147483647 } ]
>> string:  [{"user_id":"2fc48bd0-a62c-11e5-9a32-a31e4e4cd6a5","name":"wuwanyu","psw":"123","school":"Northeastern university","major":"Communication engineering","points":"10","datems":"1450514
441486","createdAt":"2015-12-19T08:42:31.000Z","updatedAt":"2015-12-19T08:42:31.000Z","ID":3,"phone":2147483647}]
>> json:  [ { user_id: '2fc48bd0-a62c-11e5-9a32-a31e4e4cd6a5',
    name: 'wuwanyu',
    psw: '123',
    school: 'Northeastern university',                                                                                                                                           
    major: 'Communication engineering',                                                                                                                                            
    points: '10',
    datems: '1450514441486',
    createdAt: '2015-12-19T08:42:31.000Z',
    updatedAt: '2015-12-19T08:42:31.000Z',
    ID: 3,
    phone: 2147483647 } ]
>> user.name:  wuwanyu
18
user5545457

Vous pouvez copier toutes les propriétés énumérables d'un objet dans un nouvel objet par Object.assign (target, ... sources) :

trivial_object = Object.assign({}, non_trivial_object);

donc dans votre scénario, il devrait suffire de changer

ret.Push(i);

à

ret.Push(Object.assign({}, i));
6
Jan Šourek

Avec l'approche Object.prototype, JSON.parse(JSON.stringify(rows)) renvoie l'objet, extrait les valeurs avec Object.values()

var resultArray = Object.values(JSON.parse(JSON.stringify(rows)))

Usage:

resultArray.forEach(function(v){ console.log(v) })
4
FranSanchis

vous essayez le code qui donne JSON sans rowdatapacket:

var ret = [];
conn.query(SQLquery, function(err, rows, fields) {
    if (err)
        alert("...");
    else {
        ret = JSON.stringify(rows);
    }
    doStuffwithTheResult(ret);
}
2
Kumaresan Perumal

J'ai trouvé un moyen facile

Object.prototype.parseSqlResult = function () {
    return JSON.parse(JSON.stringify(this[0]))
}

Au niveau de la couche de base de données, analyser en tant que

let users= await util.knex.raw('select * from user')
    return users.parseSqlResult()

Cela retournera les éléments sous forme de tableau JSON normal.

1
M14

sortir de la réponse de jan de la copie superficielle de l'objet, une autre implémentation propre à l'aide de la fonction map,

Niveau élevé de ce que fait cette solution: parcourez toutes les lignes et copiez-les en tant qu'objets js valides. 

// function  will be used on every row returned by the query
const objectifyRawPacket = row => ({...row});

// iterate over all items and convert the raw packet row -> js object
const convertedResponse = results.map(objectifyRawPacket);

Nous avons tiré parti de la fonction de mappage de tableau: il examinera chaque élément du tableau, l'utilisera comme entrée de la fonction et insérera la sortie de la fonction dans le tableau que vous affectez. 

plus spécifiquement sur la fonction objectifyRawPacket: chaque fois qu’elle est appelée, elle voit le "{RawDataPacket}" depuis le tableau source. Ces objets agissent beaucoup comme des objets normaux - l’opérateur "..." (propagation) copie les éléments du tableau après les points, ce qui consiste essentiellement à copier les éléments dans l’objet appelé. 

Les parenthèses autour de l'opérateur d'étalement de la fonction sont nécessaires pour renvoyer implicitement un objet à partir d'une fonction de flèche.

0
Julian