You might know this problem: for some reason Akismet didn’t quite work and now you have this old WordPress blog with thousands of spam comments. Of course, you could try the ‘Check for spam’ button in the comments panel, but that might not work for every comment.
So here’s a little guide to help you fix this problem easily using phpMyAdmin (which is probably already installed on your server) and some SQL magic.
Warning: you want to make a backup of your database first before using this guide, in case you accidentally delete more stuff than you want.
Okay, let’s get started! First, log into phpMyAdmin and locate the WordPress database (it’s probably called ‘wp’ or ‘wordpress’). From the left-hand column select the ‘wp_comments’ table, and then on the top, click the ‘Search’ button.
In this new screen look for the ‘comment_author_url’ field. From the ‘operator’ dropdown there select the ‘LIKE %…%’ option and enter ‘http’ in the value field. Now press search.
In my experience virtually all spam uses the ‘website’ field to link to their spam site. This list might also include valid comments. If that’s the case but you’re sure you haven’t had a lot of comments in the post few months you could check for the last ‘valid’ comment, note the ‘comment_ID’ and add that to the search as well (use the > operator in the search tab). Otherwise..it’s either bad luck for those people or you need to weed out all the valid comments by hand…
So, now you’ve got this whole list. To delete them simply press the ‘edit’ link underneath the SQL statement on top of the page. It will probably look something like this:
SELECT * FROM `wp_comments` WHERE LIKE '%http%'
Change the SELECT * into DELETE so it looks like this:
DELETE FROM `wp_comments` WHERE LIKE '%http%'
You’ll get a warning because you’re gonna delete stuff. Press OK and all those pesky comments will be gone!
If this guide was helpful to you feel free to share it on Twitter or Facebook or leave a comment here.
Here’s an interesting problem i recently encountered.
I’ve got a site using Require.js. I’m loading an external library that doesn’t use Require. This library loads some external dependencies, one of them being Mustache.js. This library doesn’t use Require for loading dependencies, but a simple system of inserting <script> tags with a src tag.
See the problem? Because i’m using Require this module exports itself using the define() call. However the external library i’m using expects its to be in global scope so doing
Mustache.render()
Won’t work.
Actually, for some weird reason (maybe something with lazy loading and evaluating JS?) this seems to work in Chrome, but on the iPad it fails.
So, who’s wrong here? Should the UMD definition be redefined to always export a global variable? Or is the external library just ‘doing it wrong’ and should they not use an external library like this?
Unfortunately there’s no clearcut answer to that. For now, i see three different ways to fix this.
Load the UMD module before Require in a script tag
So, do something like this:
<script src="http://example.com/mustache.js"></script>
<script src="http://example.com/require.js"></script>
<script>
// Mustache will be available before Require, and will attach itself
// to the global scope.
var html = Mustache.render();
</script>
Load the UMD module with Require, but re-attach to the global scope
This is a bit hacky, but maybe a better solution than having a seperate script tag.
// First load the UMD module dependency and attach to global scope again
require(['/example/mustache'], function(Mustache) {
window.Mustache = Mustache; // re-attach to global scope
// Now load the problematic module
require(['/example/module'], function() {
// This module can use Mustache as a global variable
});
});
Change the UMD definition
I guess this is only interesting if the problematic dependency is also under your control, but you could change the UMD definition to something like this:
Apparently defining ‘dynamic’ content in a class doesn’t work.
The solution: either add the array in the constructor:
class Say {
private $fns;
function __construct() {
$this->fns = [
"hello" => function($name, $name2 = false) {
echo empty($name2) ? "Hello $name" : "Hello $name and $name2";
},
"bye" => function($name) {
echo "Bye $name";
}
];
foreach ($this->fns as $fn) {
call_user_func_array($fn, func_get_args());
}
}
}
$say = new Say("foo");
$say = new Say("foo", "bar");
Or (slightly better in terms of readable code) define the functions in the class and reference them from the array
class Say {
private $fns = ['hello', 'bye'];
function __construct() {
foreach ($this->fns as $fname) {
$fn = array($this, $fname);
call_user_func_array($fn, func_get_args());
}
}
public function hello($name, $name2 = false) {
echo empty($name2) ? "Hello $name" : "Hello $name and $name2";
}
public function bye($name) {
echo "Bye $name";
}
}
$say = new Say("foo");
$say = new Say("foo", "bar");
Et voila, a nice way to write flexible PHP!
BONUS: if you don’t want to write out all the methods by hand in the $fns array you could use this dirty trick to get all function names in the class without the ‘magic’ methods like __construct and __autoload:
class Say {
function __construct() {
$fnames = array_filter(get_class_methods($this), function($name) {
return $name[0] != "_";
});
foreach ($fnames as $fname) {
$fn = array($this, $fname);
call_user_func_array($fn, func_get_args());
}
}
public function hello($name, $name2 = false) {
echo empty($name2) ? "Hello $name" : "Hello $name and $name2";
}
public function bye($name) {
echo "Bye $name";
}
}
$say = new Say("foo");
$say = new Say("foo", "bar");
Ze hebben tegenwoordig Britse speciaalbieren bij de Jumbo op de Westerstraat in Amsterdam, midden in het hartje van de Jordaan. Leuk, maar hoe moet je daar een keuze uit maken, zonder dat je ze allemaal hoeft te kopen?
Geen nood, want ik ben zo’n nerd die dan foto’s maakt van alle bieren, de waarderingen en alchoholpercentages opzoekt op het geweldige BeerAdvocate en ze dan vervolgens als een lijstje op z’n website post.
Voor wie lui is: koop Flying Dog Gonzo, Fuller’s ESB en Fuller’s London Porter.
I’ve just released version 0.7.0 of Stapes.js, my MVC Javascript microframework. A big change in this release is the deprecation of the create method and the introduction of the new subclass method.
Why the change? The old system worked nicely for single modules, but was broken when trying to create an extension hierarchy. In the old system the creation of a class and the instantiation of that class were the same thing. In really simplified code that looked something like this:
The main problem with this approach is that every property that has been added to Animal after the initial create will become part of the prototype of Dog as well. Even if those properties are instance properties (e.g. Animal.bark = true instead of Animal.prototype.bark = true). This lead to difficult to detect bugs and behaviour.
constructor will become the function that is being called when making an instance with new. All other methods in the object will become part of the class prototype.
The new Module is just a standard Javascript class, so you can add prototype properties using Module.prototype or static properties using direct assignment. Stapes has two convenience methods for this called extend and proto that allow you to quickly add an object of properties to the prototype or directly to the module.
Inheritance can be done by simply calling subclass on a newly created class. The instanceof operator now works correctly too:
Every module now gets a parent property, referencing the parent’s prototype. You can use this to still call a parent method if you’ve overwritten it.
Note that for backwards compatibility the create method on the Stapes global will still work. However, because of the obvious problems it won’t work anymore on submodules. In the future i’ll remove Stapes.create. If you like the old style i recommend you switch to something like var module = (Stapes.subclass()).extend() which is more or less the same as the old Stapes.create().extend() pattern.
So, that’s it. Please leave any questions and remarks in the question section below or file tickets on Github.
Juist, het is weer die tijd van het jaar. Het einde van het jaar betekent: een lijstje, met de beste albums van het jaar. Het ultieme muzieknerd-ding.
2012 was wat mij betreft geen al te best jaar. Ik heb een hoop geluisterd, maar er was weinig wat er echt enorm uitsprong, veel dingen die zo-zo waren. Weinig verrassends. Maar misschien word ik ook wel oud en ben ik niet meer zo van de nieuwe muziek.
Net zoals voorgaande jaren heb ik bij alle albums die op Spotify beschikbaar zijn een icoontje gezet waar je direct op kan klikken, en heb ik een YouTube mix gemaakt met de beste nummers van elk album. Veel luisterplezier en een mooi 2013!
Daar zijn we weer. De Lijst. Voor de eerste keer heb ik naast een lijst met beste muziekalbums ook een lijst gemaakt met mijn favoriete films van het jaar. Voor een volledige lijst van alle films die ik dit jaar heb gezien klik hier. Ik heb zowel documentaires als fictie op de lijst staan.
For those who want to detect if a (touch) browser supports the overflow-scrolling property for ‘native style momentum scrolling’ i’ve written a little script that doesn’t need any dependencies like Modernizr.
Thanks to people submitting issues many of the changes are straight from the small but vocal Stapes community :)
New features include:
A silent flag for set, push and remove that makes it possible to update attributes without change events being triggered.
The above methods, and update can now be chained, just like many of jQuery’s methods.
remove now also triggers namespaced events
One change that might be a bit controversial is the removal of the whole Stapes.util module, with lots of Underscore.js-like methods. These were initially added in 0.4, but i’ve come to the conclusion that they’re not needed. The focus of Stapes should be on simplicity and on ‘do one thing and do it well‘. The utility methods are widely available in other libraries (like Underscore), many of them are also available in ES5-compatible browsers (such as Array.prototype.map and Function.prototype.bind.
If you have old code that depends on Stapes.util you might find the compatibility plugin useful.
If you recently tried reading a Google Plus post without having an account you’ve probably seen something very similar to this:
Lots of UI that you don’t use. And most of it is ‘fixed’ to the screen, so when you’re reading the post most of your screen is filled with useless buttons like ‘Join Google Plus’.
I’ve written a really simple and basic Userscript to remove most of this UI.
