C'est le comportement normal, standard et attendu que book === bookFound.
Si tu sérialises oui tu vas casser book === bookFound, mais, si tu prévois de sérialiser alors, tu sais que tu ne pourras jamais avoir book === bookFound, dans ce cas tu redéfinis === pour que ça fasse une comparaison d'objet selon tes critères.
En Scala on peut aussi utiliser une case class :
Je ne saurais te dire exactement le fonctionnement d'une case class, mais pour te montrer la différence niveau représentation :
Si j'affiche book d'une class normal ça me donne : Book@48ff2413
Si j'affiche book d'une case class ça me donne : Book(Lorem Ipsum,Lorem ipsum dolor sit amet, consectetur adipisicing elit,...)
Pour bien comprendre les case class : http://alblue.bandlem.com/2007/12/scala-...-case.html
Je rajouterais que tu mélanges un peu tout je trouve, puisque en programmation on ne s'amuse jamais à comparer les objets ou leur id par référence dans un cas comme ça. Puisque ça ne sert à rien et n'apporte que des problèmes.
Tiens au passage, j'avais pas bien regardé le début du topic.
Ton benchmark est faux en plus, voici le bon :
Et là... tada magie :
forEachCallback: 13
for + callback: 19
forEach: 439
Il y a bien un écart, mais déjà bien moins flagrant.
Si tu sérialises oui tu vas casser book === bookFound, mais, si tu prévois de sérialiser alors, tu sais que tu ne pourras jamais avoir book === bookFound, dans ce cas tu redéfinis === pour que ça fasse une comparaison d'objet selon tes critères.
import scala.collection.mutable.ListBuffer
trait StorageLibrary
{
def store(book: Book): ListBuffer[Book]
def getByTitle(title: String): Option[Book]
}
class Book(protected var title: String, protected var text: String)
{
def getTitle = title
def getText = text
def equals(book: Book) = book.getTitle == getTitle
}
class Storage extends StorageLibrary
{
protected val books = new ListBuffer[Book]
def store(book: Book) = books += book
def getByTitle(title: String): Option[Book] = books.find(_.getTitle == title)
}
class Library(val storage: StorageLibrary)
{
def addBook(book: Book) = storage.store(book)
def getByTitle(title: String): Option[Book] = storage.getByTitle(title)
}
object Main extends App
{
val storage = new Storage
val library = new Library(storage)
val book = new Book("Lorem Ipsum", "Lorem ipsum dolor sit amet, consectetur adipisicing elit,...")
val sameBook = new Book("Lorem Ipsum", "Lorem ipsum dolor sit amet, consectetur adipisicing elit,...")
library.addBook(book)
val bookFound = library.getByTitle("Lorem Ipsum")
bookFound match {
case None => println("Book not found")
case Some(book) => {
println("Book found : " + book)
println("Book same : " + book.equals(sameBook))
}
}
}En Scala on peut aussi utiliser une case class :
import scala.collection.mutable.ListBuffer
trait StorageLibrary
{
def store(book: Book): ListBuffer[Book]
def getByTitle(title: String): Option[Book]
}
case class Book(protected var title: String, protected var text: String)
{
def getTitle = title
def getText = text
}
class Storage extends StorageLibrary
{
protected val books = new ListBuffer[Book]
def store(book: Book) = books += book
def getByTitle(title: String): Option[Book] = books.find(_.getTitle == title)
}
class Library(val storage: StorageLibrary)
{
def addBook(book: Book) = storage.store(book)
def getByTitle(title: String): Option[Book] = storage.getByTitle(title)
}
object Main extends App
{
val storage = new Storage
val library = new Library(storage)
val book = Book("Lorem Ipsum", "Lorem ipsum dolor sit amet, consectetur adipisicing elit,...")
val sameBook = Book("Lorem Ipsum", "Lorem ipsum dolor sit amet, consectetur adipisicing elit,...")
library.addBook(book)
val bookFound = library.getByTitle("Lorem Ipsum")
bookFound match {
case None => println("Book not found")
case Some(book) => {
println("Book found : " + book)
println("Book same : " + (book == sameBook))
}
}
}Je ne saurais te dire exactement le fonctionnement d'une case class, mais pour te montrer la différence niveau représentation :
Si j'affiche book d'une class normal ça me donne : Book@48ff2413
Si j'affiche book d'une case class ça me donne : Book(Lorem Ipsum,Lorem ipsum dolor sit amet, consectetur adipisicing elit,...)
Pour bien comprendre les case class : http://alblue.bandlem.com/2007/12/scala-...-case.html
Je rajouterais que tu mélanges un peu tout je trouve, puisque en programmation on ne s'amuse jamais à comparer les objets ou leur id par référence dans un cas comme ça. Puisque ça ne sert à rien et n'apporte que des problèmes.
Tiens au passage, j'avais pas bien regardé le début du topic.
Ton benchmark est faux en plus, voici le bon :
<html>
<head>
<script>
function test()
{
var datas = [];
for (var i = 0;i<10000000;++i)
datas.push(0);
function forEachCallback()
{
var debut = (new Date()).getTime();
for (var i=0, s=datas.length; i<s; ++i)
{
var that = datas[i];
}
var fin = (new Date()).getTime();
console.log('forEachCallback: ', fin-debut);
}
forEachCallback();
var func = function (data)
{
}
var debut = (new Date()).getTime();
for (var i=0, s=datas.length; i<s; ++i) {
func(datas[i])
}
var fin = (new Date()).getTime();
console.log('for + callback: ', fin-debut);
var func = function ()
{
}
var debut = (new Date()).getTime();
datas.forEach(func);
var fin = (new Date()).getTime();
console.log('forEach: ', fin-debut);
}
</script>
</head>
<body onload="test()">
</body>
</html>
Et là... tada magie :
forEachCallback: 13
for + callback: 19
forEach: 439
Il y a bien un écart, mais déjà bien moins flagrant.