Ich mache MongoDB-Lookups, indem ich einen String in BSON konvertiere. Kann ich vor der Konvertierung feststellen, ob die Zeichenfolge, die ich habe, eine gültige ObjectID für Mongo ist?
Hier ist das Coffeescript für meine aktuelle findByID-Funktion. Es funktioniert gut, aber ich möchte nach einem anderen Attribut suchen, wenn ich feststelle, dass die Zeichenfolge keine ID ist.
db.collection "pages", (err, collection) ->
collection.findOne
_id: new BSON.ObjectID(id)
, (err, item) ->
if item
res.send item
else
res.send 404
Antworten:
Ich habe festgestellt, dass der mongoose ObjectId-Validator gültige objectIds validiert, aber ich habe einige Fälle gefunden, in denen ungültige IDs als gültig angesehen wurden. (zB: eine beliebige 12 Zeichen lange Zeichenfolge)
var ObjectId = require('mongoose').Types.ObjectId; ObjectId.isValid('microsoft123'); //true ObjectId.isValid('timtomtamted'); //true ObjectId.isValid('551137c2f9e1fac808a5f572'); //true
Was für mich funktioniert hat, ist, eine Zeichenfolge in eine Objekt-ID umzuwandeln und dann zu überprüfen, ob die ursprüngliche Zeichenfolge mit dem Zeichenfolgenwert der Objekt-ID übereinstimmt.
new ObjectId('timtamtomted'); //616273656e6365576f726b73 new ObjectId('537eed02ed345b2e039652d2') //537eed02ed345b2e039652d2
Dies funktioniert, da sich gültige IDs nicht ändern, wenn sie in eine ObjectId umgewandelt werden. Eine Zeichenfolge, die eine falsche Gültigkeit erhält, ändert sich jedoch, wenn sie in eine objectId umgewandelt wird.
quelle
function checkObjectIdValid(id){ if(ObjectID.isValid(id)){ if(new ObjectID(id) === id){ return true } else { return false } } else { return false } }
const ObjectId = require('mongoose').Types.ObjectId; function isObjectIdValid(id) { if (ObjectId.isValid(id)) { if (String(new ObjectId(id)) === id) { return true } else { return false } } else { return false } }
es6
das für dichisObjectIdValid = id => ObjectId.isValid(id) ? String(new ObjectId(id) === id) ? true : false : false;
Sie können einen regulären Ausdruck verwenden, um dies zu testen:
CoffeeScript
if id.match /^[0-9a-fA-F]{24}$/ # it's an ObjectID else # nope
JavaScript
if (id.match(/^[0-9a-fA-F]{24}$/)) { // it's an ObjectID } else { // nope }
quelle
lol456712bbfghLLsdfr
Ich habe in der Vergangenheit den Native Node Mongodb-Treiber verwendet, um dies zu tun. Die Methode isValid überprüft, ob der Wert eine gültige BSON-Objekt-ID ist. Siehe die Dokumentation hier.
var ObjectID = require('mongodb').ObjectID; console.log( ObjectID.isValid(12345) );
quelle
ObjectId
, nichtObjectID
. :)Hier ist ein Code, den ich basierend auf der Antwort von @ andy-macleod geschrieben habe.
Es kann entweder eine int oder eine Zeichenfolge oder eine ObjectId annehmen und eine gültige ObjectId zurückgeben, wenn der übergebene Wert gültig ist, oder null, wenn er ungültig ist:
var ObjectId= require('mongoose').Types.ObjectId; function toObjectId(id) { var stringId = id.toString().toLowerCase(); if (!ObjectId.isValid(stringId)) { return null; } var result = new ObjectId(stringId); if (result.toString() != stringId) { return null; } return result; }
quelle
Wenn Sie Mongoose verwenden, können Sie mithilfe von isValidObjectId testen, ob eine Zeichenfolge 12 Byte oder eine Zeichenfolge mit 24 Hex-Zeichen enthält .
Dies ist eine aktualisierte Lösung, die von einer akzeptierten Lösung bereitgestellt wird .
quelle
Die einzige Möglichkeit, die ich gefunden habe, besteht darin, eine neue ObjectId mit dem Wert zu erstellen, den ich überprüfen möchte. Wenn die Eingabe der Ausgabe entspricht, ist die ID gültig:
function validate(id) { var valid = false; try { if(id == new mongoose.Types.ObjectId(""+id)) valid = true; } catch(e) { valid = false; } return valid; } > validate(null) false > validate(20) false > validate("abcdef") false > validate("5ad72b594c897c7c38b2bf71") true
quelle
mongoose.Types.ObjectId.isValid (Zeichenfolge) gibt immer True zurück, wenn die Zeichenfolge 12 Buchstaben enthält
let firstUserID = '5b360fdea392d731829ded18'; let secondUserID = 'aaaaaaaaaaaa'; console.log(mongoose.Types.ObjectId.isValid(firstUserID)); // true console.log(mongoose.Types.ObjectId.isValid(secondUserID)); // true let checkForValidMongoDbID = new RegExp("^[0-9a-fA-F]{24}$"); console.log(checkForValidMongoDbID.test(firstUserID)); // true console.log(checkForValidMongoDbID.test(secondUserID)); // false
quelle
Am einfachsten ist es, Ihre ObjectId-Methode in einen Try-and-Catch-Dienst einzuschließen. Dann verwenden Sie diesen Dienst, um Objecet-IDs zu verarbeiten, anstatt die Methode direkt zu verwenden:
var ObjectId = REQUIRE OR IMPORT ... // service function oid(str) { try { return ObjectId(str); } catch(err) { return false; } } // usage if (oid(USER_INPUT)) { // continue } else { // throw error }
Sie können auch null oder leere Requisiten senden, um eine neu generierte ID zu erhalten.
quelle
Der einfachste Weg, um zu überprüfen, ob die Zeichenfolge eine gültige Mongo ObjectId ist, ist die Verwendung des Mongodb- Moduls.
const ObjectID = require('mongodb').ObjectID; if(ObjectID.isValid(777777777777777)){ console.log("Valid ObjectID") }
quelle
Im Folgenden finden Sie eine Funktion, die sowohl mit der ObjectId-
isValid
Methode überprüft als auch überprüft , obnew ObjectId(id)
derselbe Wert zurückgegeben wird. Der Grund dafür,isValid
nicht genug allein zu sein, wird von Andy Macleod in der gewählten Antwort sehr gut beschrieben.const ObjectId = require('mongoose').Types.ObjectId; /** * True if provided object ID valid * @param {string} id */ function isObjectIdValid(id){ return ObjectId.isValid(id) && new ObjectId(id) == id; }
quelle
Wenn Sie die Hex-Zeichenfolge haben, können Sie diese verwenden:
ObjectId.isValid(ObjectId.createFromHexString(hexId));
quelle
Es hat eine Weile gedauert, bis ich eine gültige Lösung gefunden hatte, da die von @Andy Macleod vorgeschlagene Lösung zum Vergleichen des objectId-Werts mit einer eigenen Zeichenfolge den Express.js-Server zum Absturz brachte:
var view_task_id_temp=new mongodb.ObjectID("invalid_id_string"); //this crashed
Ich habe nur einen einfachen Versuch verwendet, um dies zu lösen.
var mongodb = require('mongodb'); var id_error=false; try{ var x=new mongodb.ObjectID("57d9a8b310b45a383a74df93"); console.log("x="+JSON.stringify(x)); }catch(err){ console.log("error="+err); id_error=true; } if(id_error==false){ // Do stuff here }
quelle
Verwenden Sie für Mungo die Funktion isValid (), um zu überprüfen, ob objectId gültig ist oder nicht
Beispiel:
var ObjectId = mongoose.Types.ObjectId; if(ObjectId.isValid(req.params.documentId)){ console.log('Object id is valid'); }else{ console.log('Invalid Object id'); }
quelle
In der Antwort der Lösung sagte Andy Macleod :
Eine Implementierung dieses Ansatzes wäre eine Funktion, die prüft, ob der übergebene Wert gültig ist
ObjectId
und mit beidenstring
undObjectId
(Objekt-) Werten arbeitet. Es würde ungefähr so aussehen:var ObjectId = require("mongoose");.Types.ObjectId; function isValidObjectId(value) { // If value is an object (ObjectId) cast it to a string var valueString = typeof value === "string" ? value : String(value); // Cast the string to ObjectId var idInstance = new ObjectId(valueString); return String(idInstance) === valueString; }
quelle
@ Ross-U Antwort ist einfach unglaublich.
Ich habe die Methoden verkettet, um eine vollständige Validierung inline durchzuführen:
documentId = id && isValid(id) && new ObjectId(id) == id ? id : null
Beachten Sie das doppelte Gleichheitszeichen, das als SEHR wichtig ist
new ObjectId()
es keinen String und ein strikter Vergleich im Vergleich zu einem normalen String (den ich in meiner Logik hatte) false zurückgibt.Die Methoden wurden von dem
mongoose
Objekt zerstört, das durch die Anforderung freigelegt wurde:const { Types: { ObjectId: { isValid }, ObjectId } } = require("mongoose");
quelle
Warnung: isValid gibt true für beliebige Zeichenfolgen mit einer Länge von 12/24 zurück, die mit einer gültigen Hex-Ziffer beginnen. Derzeit denke ich, dass dies eine bessere Überprüfung ist:
quelle
true
z'funky string'
. Jede Zeichenfolge, die die richtige Länge hat und mit einer hexadezimalen Ziffer beginnt, erfüllt diese.