W tym rozdziale znajdziesz wykaz wszystkich przykładów kodu źródłowego, które znajdują się w kategorii JS. Aby sprawdzić bardziej szczegółowy opis, kliknij odnośnik "Zobacz więcej..." pod wybraną grupą przykładów.

Obiekt globalny

Po co wprowadzono w JavaScript wartość typu liczbowego, która jednak nie jest poprawną liczbą?

NaN == 1;         // false
NaN == 0;         // false
NaN == false;     // false
NaN == null;      // false
NaN == NaN;       // false
NaN === NaN;      // false
NaN == Infinity;  // false
NaN == undefined; // false

Zobacz więcej...

Jak w języku JavaScript zapisywana jest wartość nieskończona?

Infinity > 1;  // true
-Infinity < 0; // true
1 * Infinity;  // Infinity
-1 * Infinity; // -Infinity
1 / Infinity;  // 0

Zobacz więcej...

Co zawiera zmienna, której nie przypisano żadnej wartości?

var x;
x == undefined; // true
x = 1;
x == undefined; // false
 
function f(a) {
    return a == undefined;
}
f();            // true
f(1);           // false

Zobacz więcej...

Jak napisać program, który pozwoli wykonać kod, wprowadzony przez użytkownika?

eval("2 + 2");    // 4
eval(1);          // 1
 
var x = true;
function f(a) {
    return a + '!';
}
eval("if (x) f('ok'); else f('error');"); // 'ok!'
 
eval('(');        // SyntaxError
eval('return 1'); // SyntaxError

eval(new String("2 + 2")); // new String("2 + 2")

Zobacz więcej...

Co zrobić, żeby przekształcić wartość szesnastkową (heksadecymalną) lub ósemkową (oktalną) na liczbę dziesiętną?

parseInt(" +1A ");  // 1
parseInt("1.9");    // 1
parseInt("-1.1");   // -1
parseInt("1A", 8);  // 1
parseInt("10", 8);  // 8
parseInt("0x1A");   // 26
parseInt("1a", 16); // 26
parseInt("test");   // NaN
parseInt(0, 0);     // 0 == parseInt(0, 10)
parseInt(0, 1);     // NaN
parseInt(0, 37);    // NaN

Zobacz więcej...

W jaki sposób przekształcić tekst na liczbę?

parseFloat(" +1A ");     // 1
parseFloat("1.9");       // 1.9
parseFloat("-1.1");      // -1.1
parseFloat("314e-2");    // 3.14
parseFloat("0.0314E+2"); // 3.14
parseFloat("0x1A");      // 0
parseFloat("test");      // NaN

Zobacz więcej...

Jak sprawdzić, czy funkcja zwróciła prawidłową liczbę?

isNaN(parseInt("1"));    // false
isNaN(parseInt("test")); // true

Zobacz więcej...

Jak sprawdzić, czy funkcja zwróciła liczbę skończoną?

isFinite(Infinity);  // false
isFinite(-Infinity); // false
isFinite(1);         // true
isFinite(1 / 0);     // false

Zobacz więcej...

W jaki sposób zdekodować adres URI/URL?

decodeURI("http://example.com/%7Btest%7D"); // "http://example.com/{test}"
decodeURI("%XX");                           // URIError

Zobacz więcej...

W jaki sposób zdekodować wartość z adresu URI/URL?

decodeURIComponent("%7Btest%7D"); // "{test}"
decodeURIComponent("%XX");        // URIError

Zobacz więcej...

W jaki sposób zakodować tekst do postaci adresu URI/URL?

encodeURI("http://example.com/{test}"); // "http://example.com/%7Btest%7D"
encodeURI("\uDC00");                    // URIError

Zobacz więcej...

W jaki sposób zakodować tekst, tak aby można go było wstawić do adresu URI/URL?

encodeURIComponent("{test}"); // "%7Btest%7D"
encodeURIComponent("\uDC00"); // URIError

Zobacz więcej...

Object

Jak przekształcić wartość prostą (logiczną, liczbę, tekst) na obiekt?

Object(true);      // new Boolean(true)
Object(1);         // new Number(1)
Object("test");    // new String("test")
Object();          // new Object()
Object(null);      // new Object()
Object(undefined); // new Object()

Zobacz więcej...

Jak utworzyć nowy obiekt?

new Object(true);        // new Boolean(true)
new Object(1);           // new Number(1)
new Object("test");      // new String("test")
new Object();            // {}
new Object(null);        // {}
new Object(undefined);   // {}
 
var obj = {};
new Object(obj) === obj; // true
new Object(obj) === {};  // false

Zobacz więcej...

W jaki sposób pobrać prototyp podanej instancji obiektu?

Object.getPrototypeOf({});
Object.getPrototypeOf(true);   // TypeError
Object.getPrototypeOf(1);      // TypeError
Object.getPrototypeOf("test"); // TypeError
Object.getPrototypeOf(null);   // TypeError

Zobacz więcej...

Jak pobrać deskryptor właściwości podanej instancji obiektu?

Object.getOwnPropertyDescriptor({p: 1}, "p"); // {value: 1, writable: true, enumerable: true, configurable: true}
Object.getOwnPropertyDescriptor({}, "p");     // undefined
 
var Cls = function () {
    this.p = 1;
};
Cls.prototype.m = function () {};
var obj = new Cls();
Object.getOwnPropertyDescriptor(obj, "p");    // {value: 1, writable: true, enumerable: true, configurable: true}
Object.getOwnPropertyDescriptor(obj, "m");    // undefined
 
Object.getOwnPropertyDescriptor(true, "p");   // TypeError
Object.getOwnPropertyDescriptor(1, "p");      // TypeError
Object.getOwnPropertyDescriptor("test", "p"); // TypeError
Object.getOwnPropertyDescriptor(null, "p");   // TypeError

Zobacz więcej...

Jak pobrać listę nazw wszystkich właściwości, które posiada obiekt?

Object.getOwnPropertyNames({p: 1}); // ["p"]
Object.getOwnPropertyNames({});     // []
 
var obj = {};
Object.defineProperty(obj, "p", {enumerable: false});
Object.getOwnPropertyNames(obj);    // ["p"]
 
var Cls = function () {
    this.p = 1;
};
Cls.prototype.m = function () {};
obj = new Cls();
Object.getOwnPropertyNames(obj);    // ["p"]
 
Object.getOwnPropertyNames(true);   // TypeError
Object.getOwnPropertyNames(1);      // TypeError
Object.getOwnPropertyNames("test"); // TypeError
Object.getOwnPropertyNames(null);   // TypeError

Zobacz więcej...

Jak utworzyć obiekt bazujący na podanym wzorcu, ale bez wywoływania konstruktora?

Object.getPrototypeOf(Object.create(null)) === null;      // true
var obj = Object.create(Object.prototype);
Object.getPrototypeOf(obj) === Object.getPrototypeOf({}); // true
Object.create({}, {p: {value: 1}}).p;                     // 1
Object.create(true);                                      // TypeError
Object.create(1);                                         // TypeError
Object.create("test");                                    // TypeError

Zobacz więcej...

Jak w języku JavaScript utworzyć zmienną tylko do odczytu?

var obj = {test: 3};
Object.defineProperty(obj, "p", {value: 1});
obj.p = 2;
obj.p;                                             // 1
for (var key in obj) key;                          // "test"
 
Object.defineProperty(obj, "dynamic", {
    get: function () {
        return obj.test * 2;
    },
    set: function (value) {
        obj.test = value < 0 ? NaN : value / 2;
    }
});
obj.dynamic;                                       // 6
obj.dynamic = 4;
obj.test                                           // 2
obj.dynamic = -1;
obj.test;                                          // NaN
 
Object.defineProperty(obj, "p", {writable: true}); // TypeError
Object.defineProperty(true, "p", {});              // TypeError
Object.defineProperty(1, "p", {});                 // TypeError
Object.defineProperty("test", "p", {});            // TypeError
Object.defineProperty(null, "p", {});              // TypeError

Zobacz więcej...

Jak za jednym razem skonfigurować właściwości obiektu (np. tylko do odczytu)?

var obj = Object.defineProperties({}, {
    test: {value: 3, writable: true, enumerable: true, configurable: true},
    p: {value: 1}
});
obj.p = 2;
obj.p;                                               // 1
for (var key in obj) key;                            // "test"
 
Object.defineProperties(obj, {p: {writable: true}}); // TypeError
Object.defineProperties(true, {});                   // TypeError
Object.defineProperties(1, {});                      // TypeError
Object.defineProperties("test", {});                 // TypeError
Object.defineProperties(null, {});                   // TypeError

Zobacz więcej...

Co zrobić, aby opieczętować obiekt w taki sposób, aby jego struktura pozostała niezmienna w programie?

var obj = Object.defineProperty({p: 1}, "x", {configurable: true});
delete obj.p;
obj.p;                                                 // undefined
obj.test = 3;
 
Object.seal(obj);
obj.test;                                              // 3
obj.test = 2;
obj.test;                                              // 2
delete obj.test;
obj.test;                                              // 2
obj.p = 1;
obj.p;                                                 // undefined
 
Object.defineProperty(obj, "x", {configurable: true}); // TypeError
Object.defineProperty(obj, "p", {});                   // TypeError
Object.seal(true);                                     // TypeError
Object.seal(1);                                        // TypeError
Object.seal("test");                                   // TypeError
Object.seal(null);                                     // TypeError

Zobacz więcej...

Co zrobić, aby zamrozić obiekt w taki sposób, aby nie można go było już zmieniać?

var obj = Object.defineProperty({p: 1}, "x", {configurable: true});
delete obj.p;
obj.p;                                                 // undefined
obj.test = 3;
 
Object.freeze(obj);
obj.test;                                              // 3
obj.test = 2;
obj.test;                                              // 3
delete obj.test;
obj.test;                                              // 3
obj.p = 1;
obj.p;                                                 // undefined
 
Object.defineProperty(obj, "x", {configurable: true}); // TypeError
Object.defineProperty(obj, "p", {});                   // TypeError
Object.freeze(true);                                   // TypeError
Object.freeze(1);                                      // TypeError
Object.freeze("test");                                 // TypeError
Object.freeze(null);                                   // TypeError

Zobacz więcej...

Co zrobić, aby zablokować możliwość rozszerzania struktury obiektu?

var obj = Object.defineProperty({p: 1}, "x", {value: 2, writable: false, configurable: true});
delete obj.p;
obj.test;                            // undefined
obj.test = 3;
 
Object.preventExtensions(obj);
obj.test;                            // 3
obj.test = 2;
obj.test;                            // 2
delete obj.test;
obj.test;                            // undefined
obj.p = 1;
obj.p;                               // undefined
obj.x = 1;
obj.x;                               // 2
Object.defineProperty(obj, "x", {writable: true});
obj.x = 1;
obj.x;                               // 1
 
Object.defineProperty(obj, "p", {}); // TypeError
Object.preventExtensions(true);      // TypeError
Object.preventExtensions(1);         // TypeError
Object.preventExtensions("test");    // TypeError
Object.preventExtensions(null);      // TypeError

Zobacz więcej...

Jak sprawdzić, czy obiekt jest opieczętowany, tzn. nierozszerzalny i niekonfigurowalny?

Object.isSealed({});                           // false
Object.isSealed(Object.seal({}));              // true
Object.isSealed(Object.freeze({}));            // true
Object.isSealed(Object.preventExtensions({})); // true
var obj = Object.preventExtensions(Object.defineProperty({}, "x", {writable: false, configurable: false}));
Object.isSealed(obj);                          // true
obj = Object.preventExtensions(Object.defineProperty({}, "x", {writable: true, configurable: false}));
Object.isSealed(obj);                          // true
obj = Object.defineProperty({}, "x", {configurable: false});
Object.isSealed(obj);                          // false
obj = Object.preventExtensions(Object.defineProperty({}, "x", {configurable: true}));
Object.isSealed(obj);                          // false
 
Object.isSealed(true);                         // TypeError
Object.isSealed(1);                            // TypeError
Object.isSealed("test");                       // TypeError
Object.isSealed(null);                         // TypeError

Zobacz więcej...

Jak sprawdzić, czy obiekt jest zamrożony, tzn. nierozszerzalny, niekonfigurowalny i niezmienny?

Object.isFrozen({});                           // false
Object.isFrozen(Object.seal({}));              // true
Object.isFrozen(Object.freeze({}));            // true
Object.isFrozen(Object.preventExtensions({})); // true
var obj = Object.preventExtensions(Object.defineProperty({}, "x", {writable: false, configurable: false}));
Object.isFrozen(obj);                          // true
obj = Object.preventExtensions(Object.defineProperty({}, "x", {writable: true, configurable: false}));
Object.isFrozen(obj);                          // false
obj = Object.defineProperty({}, "x", {configurable: false});
Object.isFrozen(obj);                          // false
obj = Object.preventExtensions(Object.defineProperty({}, "x", {configurable: true}));
Object.isFrozen(obj);                          // false
 
Object.isFrozen(true);                         // TypeError
Object.isFrozen(1);                            // TypeError
Object.isFrozen("test");                       // TypeError
Object.isFrozen(null);                         // TypeError

Zobacz więcej...

Jak sprawdzić, czy obiekt jest rozszerzalny, tzn. nie można nic nowego do niego dodawać?

Object.isExtensible({});                           // true
Object.isExtensible(Object.seal({}));              // false
Object.isExtensible(Object.freeze({}));            // false
Object.isExtensible(Object.preventExtensions({})); // false
var obj = Object.defineProperty({}, "x", {configurable: false});
Object.isExtensible(obj);                          // true
 
Object.isExtensible(true);                         // TypeError
Object.isExtensible(1);                            // TypeError
Object.isExtensible("test");                       // TypeError
Object.isExtensible(null);                         // TypeError

Zobacz więcej...

W jaki sposób pobrać listę nazw wszystkich widocznych właściwości obiektu?

Object.keys({p: 1}); // ["p"]
Object.keys({});     // []
 
var obj = {};
Object.defineProperty(obj, "p", {enumerable: false});
Object.keys(obj);    // []
 
Object.keys(true);   // TypeError
Object.keys(1);      // TypeError
Object.keys("test"); // TypeError
Object.keys(null);   // TypeError

Zobacz więcej...

Object.prototype

Gdzie jest zapisany konstruktor obiektu ogólnego?

Object.prototype.constructor === Object;  // true
new Object().constructor === Object;      // true
Object.prototype.constructor === Boolean; // false
Object.prototype.constructor === Number;  // false
Object.prototype.constructor === String;  // false
Object.prototype.constructor === Array;   // false

Zobacz więcej...

W jaki sposób przekształcić obiekt na prosty tekst?

new Object().toString();                            // "[object Object]"
new Object() + "";                                  // "[object Object]"
 
Object.prototype.toString.call(undefined);          // "[object Undefined]"
Object.prototype.toString.call(null);               // "[object Null]"
Object.prototype.toString.call(new Boolean(true));  // "[object Boolean]"
Object.prototype.toString.call(new Number(1));      // "[object Number]"
Object.prototype.toString.call(new String("test")); // "[object String]"
Object.prototype.toString.call(new Array());        // "[object Array]"
 
Object.prototype.toString.call(true);               // "[object Boolean]"
Object.prototype.toString.call(1.2);                // "[object Number]"
Object.prototype.toString.call("test");             // "[object String]"
 
var Cls = function () {};
new Cls() + "";                                     // "[object Object]"
Object.prototype.toString.call(new Cls());          // "[object Object]"
Cls.prototype.toString = function () {
    return "[object Cls]";
};
new Cls() + "";                                     // "[object Cls]"

Zobacz więcej...

W jaki sposób przekształcić obiekt na tekst zapisany w rodzimym języku użytkownika?

new Object().toLocaleString();                   // "[object Object]"
 
Object.prototype.toLocaleString.call(true);      // "true"
Object.prototype.toLocaleString.call(1.2);       // "1.2"
Object.prototype.toLocaleString.call("test");    // "test"
 
Object.prototype.toLocaleString.call(undefined); // TypeError
Object.prototype.toLocaleString.call(null);      // TypeError

Zobacz więcej...

Jak przekształcić złożony obiekt na wartość prostą (logiczną, liczbę, tekst)?

Object(true).valueOf();   // true
Object(1).valueOf();      // 1
Object("test").valueOf(); // "test"
 
var obj = {};
obj.valueOf() === obj;    // true

Zobacz więcej...

W jaki sposób sprawdzić, czy obiekt posiada właściwość o podanej nazwie?

var obj = {test: 1, x: undefined};
obj.m = function () {};
 
obj.hasOwnProperty("test"); // true
obj.hasOwnProperty("x");    // true
obj.hasOwnProperty("m");    // true
obj.hasOwnProperty("p");    // false
 
delete obj.x;
obj.hasOwnProperty("x");    // false
 
var Cls = function () {
    this.p = 1;
};
Cls.prototype.m = function () {};
obj = new Cls();
obj.hasOwnProperty("p");    // true
obj.hasOwnProperty("m");    // false

Zobacz więcej...

W jaki sposób sprawdzić, czy podany obiekt jest prototypem określonej instancji obiektu?

var Device = function () {};
 
var Computer = function () {};
Computer.prototype = Object.create(Device.prototype);
 
var Laptop = function () {};
Laptop.prototype = Object.create(Computer.prototype);
 
Device.prototype.isPrototypeOf(new Device());   // true
Device.prototype.isPrototypeOf(new Computer()); // true
Device.prototype.isPrototypeOf(new Laptop());   // true
Computer.prototype.isPrototypeOf(new Laptop()); // true
Object.prototype.isPrototypeOf(new Laptop());   // true
Object.prototype.isPrototypeOf({});             // true
 
Computer.prototype.isPrototypeOf(new Device()); // false
Object.prototype.isPrototypeOf(true);           // false
Object.prototype.isPrototypeOf(1);              // false
Object.prototype.isPrototypeOf("test");         // false
Object.prototype.isPrototypeOf(null);           // false

Zobacz więcej...

Jak sprawdzić, czy podana właściwość będzie dostępna w pętli?

var obj = {test: undefined};
Object.defineProperty(obj, "p", {enumerable: false});
 
obj.propertyIsEnumerable("test"); // true
obj.propertyIsEnumerable("p");    // false
obj.propertyIsEnumerable("x");    // false

Zobacz więcej...

Function

Jak napisać program, który pozwoli dynamicznie utworzyć funkcję, na podstawie kodu wprowadzonego przez użytkownika? Jak sprawdzić, ile argumentów przyjmuje funkcja?

var f = new Function();
f();                               // undefined
 
f = new Function("return 1");
f();                               // 1
 
f = new Function("a", "b", "return a + b");
f(1, 2);                           // 3
 
f = new Function("a, b", "c", "return (a + b) * c");
f(1, 2, 3);                        // 9
 
// Funkcja anonimowa:
f = function (a, b, c) {
    return (a + b) * c;
};
f(1, 2, 3);                        // 9
 
new Function("{");                 // SyntaxError
new Function("a + b", "return 1"); // SyntaxError

var f = function (a, b) {
    return a + b;
};
 
f.length;   // 2
f.length = 1;
f.length;   // 2
f();        // NaN
f(1, 2, 3); // 3

Zobacz więcej...

Czy Function.length zawiera tę samą wartość co Function.prototype.length?

Function.length;       // 1
Function.length = 2;
Function.length;       // 1
Object.keys(Function); // []

Zobacz więcej...

Function.prototype

Gdzie jest zapisany konstruktor funkcji?

Function.prototype.constructor === Function; // true
new Function().constructor === Function;     // true
Function.prototype.constructor === Object;   // false

Zobacz więcej...

Jak pobrać kod (definicję) funkcji?

new Function().toString();                   // np.: "function anonymous() {\n\n}"
new Function("a", "b", "return a + b") + ""; // np.: "function anonymous(a, b) {\nreturn a + b\n}"
 
Function.prototype.toString.call({});        // TypeError
Function.prototype.toString.call(null);      // TypeError
Function.prototype.toString.call(undefined); // TypeError

Zobacz więcej...

Jak wywołać dowolną funkcję z listą argumentów zapisaną w tablicy?

var f = function (a, b) {
    return a + b;
};
var args = [1, 2];
 
f(args);                                  // "1,2undefined"
f.apply(null, args);                      // 3
 
var Person = function (name) {
    this.name = name;
};
Person.prototype.speak = function (speech) {
    return this.name + ": " + speech;
};
 
var Computer = function (name) {
    this.name = name;
};
 
var obj = new Computer('HAL 9000');
var txt = 'My mind is going. I can feel it.';
Person.prototype.speak.apply(obj, [txt]); // "HAL 9000: My mind is going. I can feel it."
 
 
Function.prototype.apply.call(null);      // TypeError
Function.prototype.apply.call(undefined); // TypeError
Function.prototype.apply.call("test");    // TypeError
Function.prototype.apply.call({});        // TypeError
f.apply(null, "test");                    // TypeError

Zobacz więcej...

Jak zbudować program, który pozwoli wybrać użytkownikowi funkcję, którą należy wykonać?

var f = function (a, b) {
    return a + b;
};
 
f(1, 2);                                 // 3
f.call(null, 1, 2);                      // 3
 
var Person = function (name) {
    this.name = name;
};
Person.prototype.speak = function (speech) {
    return this.name + ": " + speech;
};
 
var Computer = function (name) {
    this.name = name;
};
 
var obj = new Computer('HAL 9000');
var txt = 'My mind is going. I can feel it.';
Person.prototype.speak.call(obj, txt);   // "HAL 9000: My mind is going. I can feel it."
 
 
Function.prototype.call.call(null);      // TypeError
Function.prototype.call.call(undefined); // TypeError
Function.prototype.call.call("test");    // TypeError
Function.prototype.call.call({});        // TypeError

Zobacz więcej...

Co zrobić, żeby w metodzie była widoczna właściwa instancja obiektu?

var Person = function (name) {
    this.name = name;
};
Person.prototype.speak = function (volume, speech) {
    return this.name + " (" + volume + "): " + speech;
};
 
var Computer = function (name) {
    this.name = name;
};
Computer.prototype.execute = function (command, args) {
    return command.apply(this, args);
};
 
var person = new Person("John");
var f = person.speak.bind(person, "loudly");
var computer = new Computer("HAL 9000");
computer.execute(f, ["Hello world!"]);           // "John (loudly): Hello world!"
var args = ["silently", "My mind is going. I can feel it."];
computer.execute(person.speak, args);            // "HAL 9000 (silently): My mind is going. I can feel it."
 
Function.prototype.bind.call(null, person);      // TypeError
Function.prototype.bind.call(undefined, person); // TypeError
Function.prototype.bind.call("test", person);    // TypeError
Function.prototype.bind.call({}, person);        // TypeError

Zobacz więcej...

Array

Jak utworzyć nową instancję tablicy, która może przechowywać listę elementów?

new Array();                                     // []
new Array(0);                                    // []
new Array(1);                                    // [undefined]
new Array("1");                                  // ["1"]
new Array(null);                                 // [null]
new Array(undefined);                            // [undefined]
var items = new Array(true, NaN, Infinity, {});
items[5] = [];
for (var i = 0; i < items.length; ++i) items[i]; // true, NaN, Infinity, {}, undefined, []
 
new Array(-1);                                   // RangeError
new Array(1.2);                                  // RangeError
new Array(NaN);                                  // RangeError
new Array(Infinity);                             // RangeError

var items = [1, 2, 3];
 
items.length = 2;
items;                   // [1, 2]
items.length = 3;
items;                   // [1, 2, undefined]
items.length = true;
items;                   // [1]
 
items.length = false;
items;                   // []
items.length = null;
items;                   // []
items.length = "";
items;                   // []
 
items.length = -1;       // RangeError
items.length = 1.2;      // RangeError
items.length = NaN;      // RangeError
items.length = Infinity; // RangeError
items.length = "test";   // RangeError

Zobacz więcej...

Jak sprawdzić, czy podany obiekt jest tablicą?

Array.isArray([]);           // true
Array.isArray(new Array());  // true
Array.isArray(Array());      // true
 
Array.isArray(Array);        // false
Array.isArray({});           // false
Array.isArray(new Object()); // false
Array.isArray(true);         // false
Array.isArray(1);            // false
Array.isArray("test");       // false
Array.isArray(null);         // false
Array.isArray(undefined);    // false
Array.isArray(NaN);          // false
Array.isArray(Infinity);     // false

Zobacz więcej...

Array.prototype

Gdzie jest zapisany konstruktor tablicy?

Array.prototype.constructor === Array;  // true
new Array().constructor === Array;      // true
Array.prototype.constructor === Object; // false

Zobacz więcej...

Jak przekształcić tablicę elementów na prosty tekst?

new Array([true, 1, "test"]).toString();             // "true,1,test"
[false, 0, "", null, undefined, NaN, Infinity] + ""; // "false,0,,,,NaN,Infinity"

Zobacz więcej...

Jak przekształcić tablicę elementów na tekst zapisany w rodzimym języku użytkownika?

new Array([1000.2]).toLocaleString(); // np.: "1 000,2"
new Array([1000.2]).toString();       // "1000.2"
var date = new Date(2000, 0, 31, 20, 30);
new Array([date]).toLocaleString();   // np.: "31 styczeń 2000 20:30:00"
new Array([date]).toString();         // np.: "Mon Jan 31 2000 20:30:00 GMT+0100"
 
var obj = {};
obj.toLocaleString = undefined;
new Array([obj]).toLocaleString();    // TypeError

Zobacz więcej...

W jaki sposób połączyć dwie tablice w jedną?

var items = [1, 2];
items.concat();          // [1, 2]
items.concat(3);         // [1, 2, 3]
items.concat(3, [4, 5]); // [1, 2, 3, 4, 5]
items;                   // [1, 2]

Zobacz więcej...

W jaki sposób przekształcić tablicę na tekst, w którym kolejne elementy będą oddzielone od siebie określonym separatorem?

var items = [1, 2];
items.join("; ");             // "1; 2"
"[" + items.join(", ") + "]"; // "[1, 2]"

Zobacz więcej...

Jak usunąć ostatni element z tablicy?

var items = [1, 2];
items.pop(); // 2
items;       // [1]
items.pop(); // 1
items;       // []
items.pop(); // undefined

Zobacz więcej...

Jak dodać nowy element na końcu tablicy?

var items = [1, 2];
items.push();              // 2
items;                     // [1, 2]
items.push(3, [4.1, 4.2]); // 4
items;                     // [1, 2, 3, [4.1, 4.2]]

Zobacz więcej...

W jaki sposób odwrócić kolejność elementów w tablicy?

var items = [1, 2, [3.1, 3.2]];
items.reverse(); // [[3.1, 3.2], 2, 1]
items;           // [[3.1, 3.2], 2, 1]

Zobacz więcej...

Jak usunąć pierwszy element z tablicy?

var items = [1, 2];
items.shift(); // 1
items;         // [2]
items.shift(); // 2
items;         // []
items.shift(); // undefined

Zobacz więcej...

W jaki sposób wyciąć część elementów tablicy?

var items = [1, 2, 3, 4];
 
items.slice();       // [1, 2, 3, 4]
items.slice(1);      // [2, 3, 4]
items.slice(-2);     // [3, 4] == items.slice(2);
items.slice(1, 3);   // [2, 3]
items.slice(1, -1);  // [2, 3] == items.slice(1, 3);
items.slice(-3, -1); // [2, 3]
 
items.slice(0, 0);   // []
items.slice(1, 1);   // []
items.slice(3, 1);   // []
items.slice(-1, -2); // []     == items.slice(3, 2);
 
items;               // [1, 2, 3, 4]

Zobacz więcej...

Jak posortować elementy tablicy w porządku alfabetycznym?

var items = [3, 2, 1];
items.sort();   // [1, 2, 3]
items;          // [1, 2, 3]
 
var f = function (x, y) {
    return y - x;
};
items.sort(f);  // [3, 2, 1]
items;          // [3, 2, 1]
 
var persons = [{name: "John"}, {name: "Anna"}, {name: "Tom"}];
f = function (x, y) {
    if (x.name < y.name) return -1;
    if (x.name > y.name) return 1;
    return 0;
};
persons.sort(f); // [{name: "Anna"}, {name: "John"}, {name: "Tom"}]

Zobacz więcej...

W jaki sposób wyciąć część elementów tablicy i zastąpić je innymi?

var items = [1, 2, 3, 4, 5];
 
items.splice();                  // []
items;                           // [1, 2, 3, 4, 5]
items.slice(0, 0);               // []
items;                           // [1, 2, 3, 4, 5]
items.splice(1, 2);              // [2, 3]
items;                           // [1, 4, 5]
items.splice(1, 0, 2, 3);        // []
items;                           // [1, 2, 3, 4, 5]
items.splice(-2, 2);             // [4, 5] == items.splice(3, 2);
items;                           // [1, 2, 3]
items.splice(1, 1, [2.1, 2.2]);  // [2]
items;                           // [1, [2.1, 2.2], 3]
items.splice(1, 10, 2, 3, 4, 5); // [[2.1, 2.2], 3]
items;                           // [1, 2, 3, 4, 5]

Zobacz więcej...

Jak dodać nowy element na początku tablicy?

var items = [1, 2];
items.unshift();                // 2
items;                          // [1, 2]
items.unshift([-1.2, -1.1], 0); // 4
items;                          // [[-1.2, -1.1], 0, 1, 2]

Zobacz więcej...

Jak sprawdzić, czy w tablicy występuje określony elementy?

var items = [1, 2, 3, 1];
items.indexOf(1);      // 0
items.indexOf(1, 1);   // 3
items.indexOf(1, -3);  // 3  == items.indexOf(1, 2)
items.indexOf(1, -10); // 0  == items.indexOf(1, 0)
items.indexOf(1, 10);  // -1 == items.indexOf(1, 4)
items.indexOf(0);      // -1

Zobacz więcej...

Jak przeszukać tablicę od końca, tak by sprawdzić, czy znajduje się w niej określony element?

var items = [1, 2, 3, 1];
items.lastIndexOf(1);      // 3
items.lastIndexOf(1, -2);  // 0 == items.lastIndexOf(1, 2)
items.lastIndexOf(1, 2);   // 0
items.lastIndexOf(1, 10);  // 3
items.lastIndexOf(1, -10); // -1
items.lastIndexOf(0);      // -1

Zobacz więcej...

Jak sprawdzić, czy wszystkie elementy tablicy spełniają podany warunek?

var items = [3, 2, 1];
 
var f = function (x) {
    return x > 0;
};
items.every(f);                   // true
 
f = function (x) {
    return x < 0;
};
items.every(f);                   // false
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value;
};
 
var tester = new GreaterThan(0);
items.every(tester.test, tester); // true
tester.tests;                     // 3
 
tester = new GreaterThan(2);
items.every(tester.test, tester); // false
tester.tests;                     // 2
 
items = [1, 2];
items[3] = 3;
items.length;                     // 4
tester = new GreaterThan(0);
items.every(tester.test, tester); // true
tester.tests;                     // 3
 
items.every(null);                // TypeError
items.every(undefined);           // TypeError
items.every({});                  // TypeError

Zobacz więcej...

Jak sprawdzić, czy przynajmniej jeden element tablicy spełnia podany warunek?

var items = [3, 2, 1];
 
var f = function (x) {
    return x > 0;
};
items.some(f);                   // true
 
f = function (x) {
    return x < 0;
};
items.some(f);                   // false
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value;
};
 
var tester = new GreaterThan(0);
items.some(tester.test, tester); // true
tester.tests;                    // 1
 
tester = new GreaterThan(4);
items.some(tester.test, tester); // false
tester.tests;                    // 3
 
items = [1, 2];
items[3] = 3;
items.length;                    // 4
tester = new GreaterThan(4);
items.some(tester.test, tester); // false
tester.tests;                    // 3
 
items[2] = undefined;
items.length;                    // 4
tester = new GreaterThan(4);
items.some(tester.test, tester); // false
tester.tests;                    // 4
 
items.some(null);                // TypeError
items.some(undefined);           // TypeError
items.some({});                  // TypeError

Zobacz więcej...

W jaki sposób przejść kolejno po wszystkich elementach tablicy?

var items = [3, 2, 1];
 
var sum = 0;
var f = function (x) {
    sum += x;
};
items.forEach(f);
sum;                      // 6;
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
    this.sum = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    if (value > this.value) {
        this.sum += value;
        return true;
    }
    return false;
};
 
var tester = new GreaterThan(0);
items.forEach(tester.test, tester);
tester.sum;               // 6
 
tester = new GreaterThan(1);
items.forEach(tester.test, tester);
tester.sum;               // 5
 
// Przerwanie pętli w trakcie:
tester = new GreaterThan(2);
items.every(tester.test, tester);
tester.sum;               // 3
tester.tests;             // 2
 
items = [1, 2];
items[3] = 3;
items.length;             // 4
tester = new GreaterThan(0);
items.forEach(tester.test, tester);
tester.sum;               // 6
tester.tests;             // 3
 
items[2] = undefined;
items.length;             // 4
tester = new GreaterThan(0);
items.forEach(tester.test, tester);
tester.sum;               // 6
tester.tests;             // 4
 
items.forEach(null);      // TypeError
items.forEach(undefined); // TypeError
items.forEach({});        // TypeError

Zobacz więcej...

W jaki sposób przekształcić wszystkie elementy tablicy?

var items = [3, 2, 1];
 
var f = function (x) {
    return -x;
};
items.map(f);                   // [-3, -2, -1]
items;                          // [3, 2, 1]
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value ? -value : value;
};
 
tester = new GreaterThan(1);
items.map(tester.test, tester); // [-3, -2, 1]
 
items = [1, 2];
items[3] = 3;
items.length;                   // 4
tester = new GreaterThan(0);
items.map(tester.test, tester); // [-1, -2, undefined, -3]
tester.tests;                   // 3
 
items[2] = undefined;
items.length;                   // 4
tester = new GreaterThan(0);
items.map(tester.test, tester); // [-1, -2, undefined, -3]
tester.tests;                   // 4
 
items.map(null);                // TypeError
items.map(undefined);           // TypeError
items.map({});                  // TypeError

Zobacz więcej...

W jaki sposób odfiltrować elementy tablicy, które nie spełniają podanego warunku?

var items = [3, 2, 1];
 
var f = function (x) {
    return x > 1;
};
items.filter(f);                   // [3, 2]
items;                             // [3, 2, 1]
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (value) {
    ++this.tests;
    return value > this.value;
};
 
tester = new GreaterThan(2);
items.filter(tester.test, tester); // [3]
tester.tests;                      // 3
 
items = [1, 2];
items[3] = 3;
items.length;                      // 4
tester = new GreaterThan(0);
items.filter(tester.test, tester); // [1, 2, 3]
tester.tests;                      // 3
 
items[2] = undefined;
items.length;                      // 4
tester = new GreaterThan(0);
items.filter(tester.test, tester); // [1, 2, 3]
tester.tests;                      // 4
 
items.filter(null);                // TypeError
items.filter(undefined);           // TypeError
items.filter({});                  // TypeError

Zobacz więcej...

Jak zredukować tablicę do pojedynczej prostej wartości?

var items = [3, 2, 1];
 
var f = function (a, x) {
    a += x;
    return a;
};
items.reduce(f, 0);      // 6
 
var GreaterThan = function (value) {
    this.value = value;
    this.tests = 0;
};
GreaterThan.prototype.test = function (sum, value) {
    ++this.tests;
    if (value > this.value) sum += value;
    return sum;
};
 
tester = new GreaterThan(1);
f = tester.test.bind(tester);
items.reduce(f);         // 5
tester.tests;            // 2
 
tester = new GreaterThan(1);
f = tester.test.bind(tester);
items.reduce(f, 0);      // 5
tester.tests;            // 3
 
items = [1, 2];
items[3] = 3;
items.length;            // 4
tester = new GreaterThan(0);
f = tester.test.bind(tester);
items.reduce(f, 0);      // 6
tester.tests;            // 3
 
items[2] = undefined;
items.length;            // 4
tester = new GreaterThan(0);
f = tester.test.bind(tester);
items.reduce(f, 0);      // 6
tester.tests;            // 4
 
items.reduce(null);      // TypeError
items.reduce(undefined); // TypeError
items.reduce({});        // TypeError
[].reduce(f);            // TypeError
new Array(3).reduce(f);  // TypeError

Zobacz więcej...

String

Jak skonwertować dowolną wartość na prosty tekst?

String();          // ""
String(undefined); // "undefined"
String(null);      // "null"
String(true);      // "true"
String(false);     // "false"
String(0);         // "0"
String(-1.2);      // "-1.2"
String(NaN);       // "NaN"
String(Infinity);  // "Infinity"
String("test");    // "test"

Zobacz więcej...

Jak przekształcić dowolną wartość na obiekt tekstowy?

new String();          // new String()
new String(undefined); // new String("undefined")
new String(null);      // new String("null")
new String(true);      // new String("true")
new String(false);     // new String("false")
new String(0);         // new String("0")
new String(-1.2);      // new String("-1.2")
new String(NaN);       // new String("NaN")
new String(Infinity);  // new String("Infinity")
new String("test");    // new String("test")

var str = "abc";
str.length; // 3
str.length = 1;
str.length; // 3
str;        // "abc"

Zobacz więcej...

Jak przekształcić kod liczbowy na odpowiadający mu znak Unicode?

String.fromCharCode(97, 98, 99); // "abc"
String.fromCharCode(65633);      // "a" (65633 % 65536 = 97)
String.fromCharCode(-65439);     // "a" (-65439 % 65536 + 65536 = 97)
String.fromCharCode(97.9);       // "a"
String.fromCharCode(" +97.9 ");  // "a"
 
String.fromCharCode();           // ""
String.fromCharCode(undefined);  // ""
String.fromCharCode(null);       // ""
String.fromCharCode(false);      // ""
String.fromCharCode(0);          // ""
String.fromCharCode(NaN);        // ""
String.fromCharCode(Infinity);   // ""
String.fromCharCode("");         // ""
String.fromCharCode("test");     // ""
String.fromCharCode("97 test");  // ""

Zobacz więcej...

String.prototype

Gdzie jest zapisany konstruktor obiekt tekstowego?

String.prototype.constructor === String; // true
new String().constructor === String;     // true
String.prototype.constructor === Object; // false

Zobacz więcej...

Jak zamienić obiekt tekstowy na prostą wartość tekstową?

new String("test").valueOf();             // "test"
String.prototype.valueOf.call("test");    // "test"
 
String.prototype.valueOf.call(null);      // TypeError
String.prototype.valueOf.call(undefined); // TypeError
String.prototype.valueOf.call({});        // TypeError

Zobacz więcej...

Jak pobrać określony znak tekstu?

"abc".charAt();          // "a"
"abc".charAt(0);         // "a"
"abc".charAt(" +0.9 ");  // "a"
"abc".charAt(null);      // "a"
"abc".charAt(undefined); // "a"
"abc".charAt(NaN);       // "a"
"abc".charAt("test");    // "a"
"abc".charAt(false);     // "a"
"abc".charAt(true);      // "b"
 
"abc".charAt(-1);        // ""
"abc".charAt(3);         // ""
"abc".charAt(Infinity);  // ""
"".charAt(0);            // ""

Zobacz więcej...

Jak pobrać kod liczbowy określonego znaku w tekście?

"abc".charCodeAt();          // 97
"abc".charCodeAt(0);         // 97
"abc".charCodeAt(" +0.9 ");  // 97
"abc".charCodeAt(null);      // 97
"abc".charCodeAt(undefined); // 97
"abc".charCodeAt(NaN);       // 97
"abc".charCodeAt("test");    // 97
"abc".charCodeAt(false);     // 97
"abc".charCodeAt(true);      // 98
 
"abc".charCodeAt(-1);        // NaN
"abc".charCodeAt(3);         // NaN
"abc".charCodeAt(Infinity);  // NaN
"".charCodeAt(0);            // NaN

Zobacz więcej...

Jak połączyć dwa teksty w jeden?

"abc".concat();             // "abc"
"abc".concat("def", "ghi"); // "abcdefghi"
"test ".concat(null);       // "test null"
"test ".concat(false);      // "test false"
"test ".concat(undefined);  // "test undefined"
"test ".concat(+1.2);       // "test 1.2"
"test ".concat(NaN);        // "test NaN"
"test ".concat(Infinity);   // "test Infinity"

Zobacz więcej...

W jaki sposób wyszukać określoną frazę w tekście?

"abc def abc".indexOf("a");       // 0
"abc def abc".indexOf("abc");     // 0
"abc def abc".indexOf("abc", 1);  // 8
"abc def abc".indexOf("abc", -8); // 0  == "abc def abc".indexOf("abc", 0)
"abc def abc".indexOf("abc", 30); // -1 == "abc def abc".indexOf("abc", 11)
"abc def abc".indexOf("ghi");     // -1
"abc def abc".indexOf("ABC");     // -1

Zobacz więcej...

W jaki sposób znaleźć ostatnie wystąpienie podanej frazy w tekście?

"abc def abc".lastIndexOf("a");       // 8
"abc def abc".lastIndexOf("abc");     // 8
"abc def abc".lastIndexOf("abc", 1);  // 0
"abc def abc".lastIndexOf("abc", -8); // 0 == "abc def abc".lastIndexOf("abc", 0)
"abc def abc".lastIndexOf("abc", 30); // 8 == "abc def abc".lastIndexOf("abc", 11)
"abc def abc".lastIndexOf("ghi");     // -1
"abc def abc".lastIndexOf("ABC");     // -1

Zobacz więcej...

W jaki sposób ułożyć tekst w porządku alfabetycznym uwzględniając polskie znaki diakrytyczne?

"abc".localeCompare("def") < 0; // true
"def" > "abc";                  // true
"def".localeCompare("abc") > 0; // true
 
"ą" < "b";                      // false
"ą".localeCompare("b"); < 0;    // true
"b" > "ą";                      // false
"b".localeCompare("ą") > 0;     // true
 
var chars = [
    " ", "`", "-", "=", "[", "]", "|", ";", "'", ",", ".", "/",
    "~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "{", "}", "\\", ":", "\"", "<", ">", "?",
    "1", "0", "2", "3", "5", "7", "4", "6", "8", "9",
    "n", "c", "a", "o", "b", "p", "d", "g", "q", "e", "m", "r", "h", "f", "s", "i", "l", "v", "w", "x", "j", "y", "u", "k", "z", "t",
    "N", "C", "A", "O", "B", "P", "D", "G", "Q", "E", "M", "R", "H", "F", "S", "I", "L", "V", "W", "X", "J", "Y", "U", "K", "Z", "T",
    "ż", "ó", "ł", "ć", "ę", "ś", "ą", "ź", "ń",
    "Ż", "Ó", "Ł", "Ć", "Ę", "Ś", "Ą", "Ź", "Ń"
];
var f = function (x, y) {
    return String.prototype.localeCompare.call(x, y);
};
chars.sort(f);
// np.: ["'", "-", " ", "!", "\"", "#", "$", "%", "&", "(", ")", "*", ",", ".",
//       "/", ":", ";", "?", "@", "[", "\\", "]", "^", "`", "{", "|", "}", "~",
//       "<", "=", ">", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
//       "a", "A", "ą", "Ą", "b", "B", "c", "C", "ć", "Ć", "d", "D", "e", "E",
//       "ę", "Ę", "f", "F", "g", "G", "h", "H", "i", "I", "j", "J", "k", "K",
//       "l", "L", "ł", "Ł", "m", "M", "n", "N", "ń", "Ń", "o", "O", "ó", "Ó",
//       "p", "P", "q", "Q", "r", "R", "s", "S", "ś", "Ś", "t", "T", "u", "U",
//       "v", "V", "w", "W", "x", "X", "y", "Y", "z", "Z", "ź", "Ź", "ż", "Ż"]

Zobacz więcej...

Jak sprawdzić, czy tekst pasuje do złożonego wzorca (wyrażenia regularnego)?

"abcd efg abc".match(/abc/);    // ["abc"]
"abcd efg abc".match(/(ab)c/);  // ["abc", "ab"]
 
"ABCd efg abc".match(/abc/i);   // ["ABC"]
"ABCd efg abc".match(/(ab)c/i); // ["ABC", "AB"]
 
"abcd efg abc".match(/abc/g);   // ["abc", "abc"]
"abcd efg abc".match(/(ab)c/g); // ["abc", "abc"]
 
"ABCd efg abc".match(/abc/ig);   // ["ABC", "abc"]
"ABCd efg abc".match(/(ab)c/ig); // ["ABC", "abc"]
 
"abcd efg abc".match(/hij/);     // null
"abcd efg abc".match(/ABC/);     // null
"abcd efg abc".match(/(AB)C/);   // null
"abcd efg abc".match(/hij/g);    // null
"abcd efg abc".match(/ABC/g);    // null
"abcd efg abc".match(/(AB)C/g);  // null

Zobacz więcej...

Co zrobić, aby zamienić w tekście wszystkie wystąpienia podanej frazy na inną?

"abcd efg abc".replace("abc", "123");      // "123d efg abc"
"abcd efg abc".replace(/abc/, "123");      // "123d efg abc"
"abcd efg abc".replace(/abc/g, "123");     // "123d efg 123"
 
"ABCd efg abc".replace(/abc/i, "123");     // "123d efg abc"
"ABCd efg abc".replace(/abc/ig, "123");    // "123d efg 123"
 
var search = /((a)b)(c)/;
var replace = "$$[$`,$&,$',$1-$01,$2-$02,$3-$03]$$";
"123 abc 456".replace(search, replace);    // "123 $[123 ,abc, 456,ab-ab,a-a,c-c]$ 456"
 
replace = "[$&,$1,$2,$3]";
"ABC abc".replace(/((a)b)(c)/ig, replace); // "[ABC,AB,A,C] [abc,ab,a,c]"
 
replace = function (substring, capture1, capture2, capture3, offset, string) {
    return "[" + substring + "," + capture1 + "," + capture2 + "," + capture3 + "," + offset + "," + string + "]";
};
"123 abc 456".replace(search, replace);    // "123 [abc,ab,a,c,4,123abc456] 456"

Zobacz więcej...

Jak wyszukać w tekście złożonego wzorca (wyrażenia regularnego)?

"abc def abc".search(/a[a-z]/); // 0
"abc def abc".search(/abc?/);  // 0
"abc def abc".search(/ABC?/i); // 0
 
"abc def abc".search(/ghi?/); // -1
"abc def abc".search(/ABC?/); // -1

Zobacz więcej...

W jaki sposób wyciąć z tekstu jego część?

"abcd".slice();       // "abcd"
"abcd".slice(1);      // "bcd"
"abcd".slice(-2);     // "cd" == "abcd".slice(2)
"abcd".slice(1, 3);   // "bc"
"abcd".slice(1, -1);  // "bc" == "abcd".slice(1, 3)
"abcd".slice(-3, -1); // "bc" == "abcd".slice(1, 3)
 
"abcd".slice(0, 0);   // ""
"abcd".slice(1, 1);   // ""
"abcd".slice(3, 1);   // ""
"abcd".slice(-1, -2); // ""   == "abcd".slice(3, 2)

Zobacz więcej...

Jak rozbić tekst na tablicę elementów?

"abc".split();           // ["abc"]
"".split();              // [""]
"".split("");            // []
"".split(/a?/);          // []
"".split("a");           // [""]
"".split(/a/);           // [""]
"abc".split("");         // ["a", "b", "c"]
"abc".split(/a?/);       // ["a", "b", "c"]
"abc".split("a");        // ["", "bc"]
"abcba".split("b");      // ["a", "c", "a"]
"abc".split("c");        // ["ab", ""]
"abcba".split(/b/);      // ["a", "c", "a"]
"abcdba".split(/b(c)?/); // ["a", "c", "d", undefined, "a"]

Zobacz więcej...

Jak wyciąć z tekstu krótki fragment?

"abcd".substring();       // "abcd"
"abcd".substring(1);      // "bcd"
"abcd".substring(-2);     // "abcd"
"abcd".substring(1, 3);   // "bc"
"abcd".substring(3, 1);   // "bc" == "abcd".substring(1, 3)
"abcd".substring(1, -1);  // "a"  == "abcd".substring(0, 1)
 
"abcd".substring(0, 0);   // ""
"abcd".substring(1, 1);   // ""
"abcd".substring(-3, -1); // ""   == "abcd".substring(0, 0)
"abcd".substring(-1, -2); // ""   == "abcd".substring(0, 0)

Zobacz więcej...

Jak zamienić tekst na małe litery?

var str = "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ";
str.toLowerCase();         // "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż"
"AbcQX 123".toLowerCase(); // "abcqx 123"

Zobacz więcej...

Jak zamienić tekst na małe litery uwzględniając język polski?

var str = "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ";
str.toLocaleLowerCase();         // np.: "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż"
"AbcQX 123".toLocaleLowerCase(); // np.: "abcqx 123"

Zobacz więcej...

Jak zamienić tekst na wielkie litery?

var str = "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż";
str.toUpperCase();         // "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ"
"Abcqx 123".toUpperCase(); // "ABCQX 123"

Zobacz więcej...

Jak zamienić tekst na wielkie litery uwzględniając język polski?

var str = "aąbcćdeęfghijklłmnńoópqrsśtuvwxyzźż";
str.toLocaleUpperCase();         // np.: "AĄBCĆDEĘFGHIJKLŁMNŃOÓPQRSŚTUVWXYZŹŻ"
"Abcqx 123".toLocaleUpperCase(); // np.: "ABCQX 123"

Zobacz więcej...

Jak usunąć niepotrzebne białe znaki na początku i na końcu tekstu?

"\t A B C\r\n".trim(); // "A B C"

Zobacz więcej...

Boolean

Jak przekształcić dowolną wartość na prostą wartość logiczną - true/false (prawda/fałsz)?

// true:
Boolean(true);
Boolean(1);
Boolean(-1.2);
Boolean(Infinity);
Boolean(-Infinity);
Boolean("test");
Boolean(" ");
Boolean("null");
Boolean("false");
Boolean("0");
Boolean("undefined");
Boolean("NaN");
Boolean([]);
Boolean([false]);
Boolean({});
 
// false:
Boolean();
Boolean(undefined);
Boolean(null);
Boolean(false);
Boolean(0);
Boolean(NaN);
Boolean("");

Zobacz więcej...

Jak przekształcić dowolną wartość na obiekt logiczny (prawda/fałsz)?

// new Boolean(true):
new Boolean(true);
new Boolean(1);
new Boolean(-1.2);
new Boolean(Infinity);
new Boolean(-Infinity);
new Boolean("test");
new Boolean(" ");
new Boolean("null");
new Boolean("false");
new Boolean("0");
new Boolean("undefined");
new Boolean("NaN");
new Boolean([]);
new Boolean([false]);
new Boolean({});
 
// new Boolean(false):
new Boolean();
new Boolean(undefined);
new Boolean(null);
new Boolean(false);
new Boolean(0);
new Boolean(NaN);
new Boolean("");

Zobacz więcej...

Boolean.prototype

Gdzie jest zapisany konstruktor obiekt logicznego?

Boolean.prototype.constructor === Boolean; // true
new Boolean().constructor === Boolean;     // true
Boolean.prototype.constructor === Object;  // false

Zobacz więcej...

Jak przekształcić wartość logiczną na prosty tekst?

true.toString();                            // "true"
new Boolean().toString();                   // "false"
Boolean.prototype.toString.call(false);     // "false"
 
Boolean.prototype.toString.call(null);      // TypeError
Boolean.prototype.toString.call(undefined); // TypeError
Boolean.prototype.toString.call(NaN);       // TypeError
Boolean.prototype.toString.call(0);         // TypeError
Boolean.prototype.toString.call("");        // TypeError
Boolean.prototype.toString.call({});        // TypeError

Zobacz więcej...

Jak przekształcić obiekt logiczny na prostą wartość logiczną - true/false (prawda/fałsz)?

true.valueOf();                            // true
new Boolean().valueOf();                   // false
Boolean.prototype.valueOf.call(false);     // false
 
Boolean.prototype.valueOf.call(null);      // TypeError
Boolean.prototype.valueOf.call(undefined); // TypeError
Boolean.prototype.valueOf.call(NaN);       // TypeError
Boolean.prototype.valueOf.call(0);         // TypeError
Boolean.prototype.valueOf.call("");        // TypeError
Boolean.prototype.valueOf.call({});        // TypeError

Zobacz więcej...

Number

W jaki sposób skonwertować dowolną wartość na liczbę?

Number();              // 0
Number(undefined);     // NaN
Number(null);          // 0
Number(true);          // 1
Number(false);         // 0
Number(new Boolean()); // 0
Number(0);             // 0
Number(1);             // 1
Number(-1.2);          // -1.2
Number(Infinity);      // Infinity
Number(new Number());  // 0
Number("test");        // NaN
Number(" +1.2 ");      // 1.2
Number("0xA");         // 10
Number("1 test");      // NaN
Number("false");       // NaN
Number(" ");           // 0
Number("");            // 0
Number(new String());  // 0
Number([]);            // 0   == Number("")
Number([0]);           // 0   == Number("0")
Number([1]);           // 1   == Number("1")
Number([1, 2, 3]);     // NaN == Number("1,2,3")
Number([true]);        // NaN == Number("true")
Number({});            // NaN == Number("[object Object]")
 
var obj = {};
obj.valueOf = undefined;
obj.toString = undefined;
Number(obj);           // TypeError

Zobacz więcej...

Jak przekształcić dowolną wartość na obiekt liczbowy?

new Number();              // new Number(0)
new Number(undefined);     // new Number(NaN)
new Number(null);          // new Number(0)
new Number(true);          // new Number(1)
new Number(false);         // new Number(0)
new Number(new Boolean()); // new Number(0)
new Number(0);             // new Number(0)
new Number(1);             // new Number(1)
new Number(-1.2);          // new Number(-1.2)
new Number(Infinity);      // new Number(Infinity)
new Number(new Number());  // new Number(0)
new Number("test");        // new Number(NaN)
new Number(" +1.2 ");      // new Number(1.2)
new Number("0xA");         // new Number(10)
new Number("1 test");      // new Number(NaN)
new Number("false");       // new Number(NaN)
new Number(" ");           // new Number(0)
new Number("");            // new Number(0)
new Number(new String());  // new Number(0)
new Number([]);            // new Number(0)
new Number([0]);           // new Number(0)
new Number([1]);           // new Number(1)
new Number([1, 2, 3]);     // new Number(NaN)
new Number([true]);        // new Number(NaN)
new Number({});            // new Number(NaN)
 
var obj = {};
obj.valueOf = undefined;
obj.toString = undefined;
new Number(obj);           // TypeError

Zobacz więcej...

Jaką największą liczbę można zapisać w JavaScript?

Number.MAX_VALUE; // 1.7976931348623157e+308
Number.MAX_VALUE = 1;
Number.MAX_VALUE; // 1.7976931348623157e+308

Zobacz więcej...

Jaką najmniejszą wartość można zapisać w JavaScript?

Number.MIN_VALUE; // 5e-324
Number.MIN_VALUE = 1;
Number.MIN_VALUE; // 5e-324

Zobacz więcej...

Jak zapisać wartość liczbową, która jednak nie jest poprawną liczbą?

Number.NaN; // NaN
Number.NaN = 1;
Number.NaN; // NaN