$labels = array(
 'name' => __('', 'domain'), // - general name for the post type, usually plural. The same as, and overridden by $post_type_object->label
 'singular_name' => __('', 'domain'), // - name for one object of this post type. Defaults to value of name
 'add_new' => _x('', 'domain'), // - the add new text. The default is Add New for both hierarchical and non-hierarchical types.
 // - When internationalizing this string, please use a gettext context matching your post type. Example: _x('Add New', 'product');
 'all_items' => __('', 'domain'), // - the all items text used in the menu. Default is the Name label
 'add_new_item' => __('', 'domain'), // - the add new item text. Default is Add New Post/Add New Page
 'edit_item' => __('', 'domain'), // - the edit item text. Default is Edit Post/Edit Page
 'new_item' => __('', 'domain'), // - the new item text. Default is New Post/New Page
 'view_item' => __('', 'domain'), // - the view item text. Default is View Post/View Page
 'search_items' => __('', 'domain'), // - the search items text. Default is Search Posts/Search Pages
 'not_found' => __('', 'domain'), // - the not found text. Default is No posts found/No pages found
 'not_found_in_trash' => __('', 'domain'), // - the not found in trash text. Default is No posts found in Trash/No pages found in Trash
 'parent_item_colon' => __('', 'domain'), // - the parent text. This string isn't used on non-hierarchical types. In hierarchical ones the default is Parent Page
 'menu_name' => __('', 'domain') // - the menu name text. This string is the name to give menu items. Defaults to value of name
 );

Den snabba enkla lösningen på detta är att i loopen explicit säga åt readmore att visas.

 global $more; $more = 0; the_content('Read ALL the article...');

Obviously.

Ett av de vanligaste problemen jag har dykt på med lokal utveckling är att root-katalogen är localhost och inte localhost/projektnamn som jag vill att det ska vara. På grund av det kommer absoluta sökvägar till stilmallar och javascript strula och inte hittas.

Lösningen på det problemet är självklart att skapa egna domäner som pekar till din lokala server och rätt projektkatalog.

För att lyckas med det behöver man lägga till lite saker på två ställen. Den ena är /etc/hosts-filen och den andra är Apache’s httpd.conf-fil. I det här exemplet kommer jag använda mig av en WordPress-installation som ligger installerad under katalogen http://localhost/wordpress och ska skapa domänen wordpress.dev.

hosts

Vissa saker skiljer sig mellan operativsystemet, och jag kommer lista OS X och Windows 7.

Mac OS X

Starta terminalen och skriv sudo nano /etc/hosts

Windows 7

Windowstangent+r (kör) och skriv in %WINDIR%\system32\drivers\etc\hosts öppna med din favorit-editor.

Sist i filen, lägg till raden:

127.0.0.1    wordpress.dev

Stäng sedan filen.

httpd.conf

Filen httpd.conf ligger i katalogen där Apache installerades och bör inte vara alltför svår att hitta. Öppna med favorit-editorn. Längst ner i filen lägg dessa rader:

<VirtualHost 127.0.0.1>
  ServerName wordpress.dev
  DocumentRoot "/Applications/MAMP/www/wordpress/"
</VirtualHost>

Din DocumentRoot skiljer sig nog.

Starta om Apache och testa sedan att navigera in till wordpress.dev. Om det inte fungerar, eller om du ska lägga till fler domäner, kan det behövas en extra rad i httpd.conf. Precis över den första VirtualHost lägg till det här:

NameVirtualHost 127.0.0.1

Det löste mina problem när det gällde flera domäner. Det finns säkert flera andra saker man kan göra med VirtualHost i Apache, som lokala subdomäner om man så vill, men det är inget jag har testat.

    //  http://stackoverflow.com/questions/5223/length-of-javascript-associative-array
    Object.size = function(obj) {
        var size = 0, key;
        for (key in obj) {
            if (obj.hasOwnProperty(key)) size++;
        }
        return size;
    };
    //Används:
    var foo = { bar: true, oh: "hai" };
    Object.size(foo); // 2

Tydligen är det farligt att lägga saker på Object.prototype, men att göra såhär skadar ingen.
EDIT
Efter en kommentar och lite testning verkar det som att den här funktionen går att lägga direkt på Object.prototype. Det verkar som att funktionen gör vad den ska, även om man lägger på fler metoder eller egenskaper på Object.property.

Det skulle isåfall se ut såhär:

    Object.prototype.size = function() { //Metoden size läggs till på alla objekt... Dvs alla typer
        var size = 0, key;
        for (key in this) {
            if (this.hasOwnProperty(key)) size++;
        }
        return size;
    };
    //Används:
    var foo = { bar: true, oh: "hai" };
    foo.size(); // 2 (size anropas direkt på objektet)

Man bör nog ändå tänka sig för innan man börjar lägga på saker på property-kedjor som är ömtåliga (Function, Object, Array osv), men om man har stor kontroll över sin kod och inga utomstående bibliotek som krockar så ska det här vara relativt ofarligt.

Tack Joacim för kommentaren, alltid kul att få såna. :p

var span = $("<span class=\"error\">").text("No u");
$("#errorcontainerthing").append(span);

Det fungerar inte i Internet Explorer 7 (och antagligen inga versioner under). Gör såhär istället:

var span = $("<span>").addClass("error").text("No u");
$("#errorcontainerthing").append(span);

Det borde fungera fint. Nu har jag sparat en timme i ditt liv.

function foo() { return "Namngiven funktion"; };
var foo = function() { return "Variabel som tilldelas en anonym funktion som värde"; };

Till och med när man använder sig av jQuery’s event som triggas när DOMen är färdigladdad använder man en anonym funktion:

$(document).ready(function(){
    //DOM färdigladdad, inne i en anonym funktion
});

$(function(){
   //Gör exakt samma sak som koden ovan, men ger +12 sexy till ditt script
});

En av de första “avancerade” sakerna man lär sig i jQuery är att om man skickar med en anonym funktion till jQuery-konstruktorn så är det samma sak som att knyta document-objektet till ready-eventet.

Anonyma funktioner är alltså väldigt användbara när man ska utföra något en gång, och kanske inte behöver använda logiken i funktionen någon annanstans, eller när man jobbar med objekt och vill tilldela en funktion till en property.

//Utan att använda anonyma funktioner:
function Person(name, beard, greeting){
    this.name = name;
    this.beard = beard;
    this.greeting = greeting;
    function sayHello() {
        log(this.greeting);
    }
    this.sayHello = sayHello;    //Skapar en funktion enbart för att tilldela den till en property
}

//Man borde istället skriva såhär:
function Person(name, beard, greeting){
    this.name = name;
    this.beard = beard;
    this.greeting = greeting;
    this.sayHai = function() {    //En anonym funktion tilldelas till this.sayHai
        log(this.greeting);
    };
}

Som alltid med JavaScript kan det vara förvirrande till en början, men om man tänker på funktioner som objekt istället för funktioner kan det bli enklare att förstå.

//Tänk såhär:
var num = 230; //Är ett namngivet Number-objekt

alert(230);    //Alert-funktion med ett anonymt Number-objekt som har värdet 230
alert(num);    //Alert-funktion med en namngiven variabel

setTimeout(function(){
    alert("hai");
}, 2000);    //En anonym funktion skickas in som parameter till setTimeout och körs efter två sekunder

function oh(){
    alert("hai");
};

setTimeout(oh, 2000);    //Gör samma sak som koden ovan, fast i det här fallet används en namngiven funktion.

window.validaton = {
     //Returnerar olika funktioner beroende på om max är satt
    length: function(min, max){
        return function(input){
            if (max) {
                return function(input) {
                    if ($(input).val().length < min || $(input).val().length > max) {
                        return false;
                    }
                    return true;
                }
            }
            return function(input) {
                if ($(input).val().length < min) {
                    return false;
                }
                return true;
            }
        }
    }
}

Det här är praktiskt sett en funktionsgenerator. När man skriver sina valideringsregler för inputfält kan det se ut såhär:

//Skapar en ny funktion för att se så värdet är längre än 5 men annars hur långt som helst.
var isLongEnough = validation.length(5); 

if (isLongEnough("#AwesomeTextInput")) { //Är man inne i en bind-funktion räcker det med this här
    log("Everything went better than expected");
} else {
   log("Needs atleast 5 characters");
}

//Alternativt
 //Anonym funktion skapas och anropas, inte reusable

if (validation.length(5)("#AwesomeTextInput")) {
    log("Everything went better than expected");
} else {
   log("Needs atleast 5 characters");
}

Tack vare closures och svart magi vet den returnerade funktionen isLongEnough vad min är satt till.
Enligt mig är det här ett snyggare sätt än att skriva specialanpassade valideringsregler för varje inputfält, plus att man får användning av currying och closures, vilket alltid är trevligt.

Closures är awesome. Nu måste jag bara hitta ett ställe där jag kan använda den här funktionen skarpt…

JavaScript har inte, som alla andra vanliga programmeringsspråk, block-level-scope och det är inte alltid tydligt på vad this pekar på. Istället använder sig JavaScript av scope på funktionsnivå, som kan förvirra när man börjar utveckla. För att koka ner det så långt jag kan:

function hello(){
    var foo = "bar";
}
hello();
alert(foo); //undefined

Eftersom att foo deklareras inne i funktionen hello() så har inte scopet utanför funktionen möjlighet att se foo. Det är alltså skillnad på lokalt scope och globalt scope (window-objektet).
När man utvecklar plugins för jQuery kan det ibland vara värt att skapa variabler utanför pluginets scope, men ändå dölja det från det globala scopet, för att undvika konflikter, överskrivna variabler och ett onödigt stort window-namespace.
Det enklaste sättet att göra det på är att lägga hela sitt plugin, med de variabler man behöver, i en anonym självanropande funktion.

(function($, window) { //http://antaru.org/self-invoking-functions-i-javascript
    //jQuery-plugins

    var foo = "bar"; //Variabel som kan kommas åt av alla plugins i scopet

    //Plugin utan closure
    $.fn.superPlugin = function() {
        //Pluginfunktionalitet
    }; 

    (function(){
        var hurr = "durr"; //Variabel som enbart existerar i det lokala scopet
        console.log(foo); //Skriver ut "bar"

        //Plugin med closure
        $.fn.closurePlugin = function() {
            //Pluginfunktionalitet
        };
    })();

    console.log(hurr); //undefined    

})(jQuery, this);

Man skulle kunna göra separata “jQuery”-closures för varje plugin, men jag gillar att ha dem samlade och sedan var för sig, om det skulle krävas, ha ett eget closure; sin egna lilla värld.
Att definiera funktioner och globala variabler i JavaScript är oftast ingen bra idé.

Tips till alla Firebug-användare

Kör det här någon gång i början av era scripts:

window.log = function() {
    log.history = log.history || [];
    log.history.push(arguments);
    if (this.console) {
        console.log(Array.prototype.slice.call(arguments));
    }
};

De som har utvecklat för Firefox och använt Firebugs härliga console.log-funktion, sen testat det i någon annan webbläsare borde känna till problemet när funktionen anropas. Det går sönder. funktionen ovan löser det; plus, om den skapas den direkt kan man anropa log-metoden precis när som helst, och det går inte sönder, även om man råkar släppa koden skarpt.
Scriptet hittade jag på Paul Irish hemsida.
Edit: Testade lite mer, och att kunna anropa log.history i firebug är faktiskt riktigt sweet.

var oh= { hai: "lol" };

Här skapas ett nytt objekt oh som innehåller en nyckel hai som har värdet “lol”. För att senare komma åt värdet med nyckeln hai finns det en del sätt:

oh.hai; //fungerar
oh["hai"] //fungerar
oh[0] //fungerar inte

Det andra sättet att hitta värdet kan vara bra om nyckeln innehåller punkter, mellanslag eller andra konstiga tecken som skulle förstöra scriptet.

Syntaxen är väldigt enkel, skapa en variabel, indikera att det är ett objekt med måsvingar ({}), sen ange värdet på nycklar i objektet med kolon istället för likamedtecken. Det är även möjligt att lagra objekt i objekt, och funktioner i nycklar, vilket gör det hela än mer awesome.
Större objekt:

var oh = {
    hai: "lol",
    foo: "bar",
    sayHi: function(){
        alert("Hi");
    },
    hello: {
        world : "Hello World"
    }
};

Med det här objektet kan man säga hej till världen genom oh.hello.world, eller bara säga hej genom oh.sayHi().

jQuery tar tillvara på associativa arrayer på väldigt många ställen, som exempelvis css()-funktionen, eller bind(), vilket gör det mycket lättare att manipulera utseendet och uppförandet av DOM-element.
Kod för att knyta multipla events till ett element:

$("#foo").bind({
    "mouseenter": function(){
        //Funktionalitet för hover in
    },
    "mouseleave": function(){
        //Funktionalitet för hover ut
    },
    "click": function(){
        //Funktionalitet för musklick
    }
});

Associativa arrays är awesome.