Sprawdź, czy zmienna jest ciągiem znaków w JavaScript

To jest to, co działa dla mnie:

if (typeof myVar === 'string' || myVar instanceof String)
// it's a string
else
// it's something else

Możesz użyć operatora typeof:

var booleanValue = true; 
var numericalValue = 354;
var stringValue = "This is a String";
var stringObject = new String( "This is a String Object" );
alert(typeof booleanValue) // displays "boolean"
alert(typeof numericalValue) // displays "number"
alert(typeof stringValue) // displays "string"
alert(typeof stringObject) // displays "object"

Przykład z tej strony. (Przykład został jednak nieco zmodyfikowany).

To nie będzie działać zgodnie z oczekiwaniami w przypadku łańcuchów utworzonych za pomocą new String(), ale jest to rzadko używane i zalecane przeciwko. Zobacz inne odpowiedzi, aby dowiedzieć się, jak sobie z tym poradzić, jeśli chcesz.

1. The Google JavaScript Style Guide mówi, aby nigdy nie używać prymitywnych wrapperów obiektów.
2. Douglas Crockford zaleca, aby prymitywne zawijasy obiektów zostały zdeprecjonowane.

Najlepszy sposób:

var s = 'String';
var a = [1,2,3];
var o = {key: 'val'};

(s.constructor === String) && console.log('its a string');
(a.constructor === Array) && console.log('its an array');
(o.constructor === Object) && console.log('its an object');
(o.constructor === Number || s.constructor === Boolean) && console.log('this won\'t run');

Każdy z nich został skonstruowany przez odpowiednią funkcję swojej klasy, jak "new Object()" itd.

Również, Duck-Typing: "Jeśli wygląda jak kaczka, chodzi jak kaczka i pachnie jak kaczka - musi być Array" Znaczenie, sprawdź jego właściwości.

Mam nadzieję, że to pomoże.

Edit; 12/05/2016

Pamiętaj, że zawsze możesz też użyć kombinacji podejść. Oto'przykład użycia inline map działań z typeof:

var type = { 'number': Math.sqrt.bind(Math), ... }[ typeof datum ];

Oto bardziej 'prawdziwy świat' przykład użycia map inline:

function is(datum) {
    var isnt = !{ null: true, undefined: true, '': true, false: false, 0: false }[ datum ];
    return !isnt;
}
console.log( is(0), is(false), is(undefined), ... );  // >> true true false

Ta funkcja użyłaby [ custom ] "type-casting" -- raczej, "type-/-value-mapping" -- aby dowiedzieć się, czy zmienna faktycznie "istnieje". Teraz możesz rozdzielić ten paskudny włos pomiędzy null & 0!

Wiele razy nie obchodzi cię nawet jej typ. Innym sposobem na obejście typowania jest łączenie zestawów Duck-Type:

this.id = "998";  // use a number or a string-equivalent
function get(id) {
    if (!id || !id.toString) return;
    if (id.toString() === this.id.toString()) http( id || +this.id );
    // if (+id === +this.id) ...;
}

Zarówno Number.prototype jak i String.prototype mają metodę .toString(). Po prostu upewniłeś się, że odpowiednik łańcuchowy liczby jest taki sam, a następnie upewniłeś się, że przekazałeś go do funkcji http jako Number. Innymi słowy, nie dbaliśmy nawet o to, jaki był jej typ.

Mam nadzieję, że to da ci więcej do pracy :)