JavaScript
strings

Syntaxis

• "string letterlijk"
• 'string literal'
• "string letterlijk met 'mismatching quotes'" // geen fouten; citaten zijn verschillend.
• "string letterlijk met" ontsnapte aanhalingstekens "" // geen fouten; aanhalingstekens zijn ontsnapt.
• `sjabloon string $ {expression}`
• String ("ab c") // retourneert een string wanneer deze in niet-constructorcontext wordt aangeroepen
• new String ("ab c") // het String-object, niet de string-primitief

Basisinformatie en tekenreeksen

Strings in JavaScript kan worden tussen enkele aanhalingstekens 'hello' , dubbele quotes "Hello" en (uit ES2015, ES6) in Template Literals (backticks) `hello` .

var hello  = "Hello";
var world  = 'world';
var helloW = `Hello World`;              // ES2015 / ES6

String() kunnen worden gemaakt van andere typen met behulp van de functie String() .

var intString = String(32); // "32"
var booleanString = String(true); // "true"
var nullString = String(null); // "null" 

Of toString() kan worden gebruikt om getallen, Booleans of objecten om te zetten in tekenreeksen.

var intString = (5232).toString(); // "5232"
var booleanString = (false).toString(); // "false"
var objString = ({}).toString(); // "[object Object]"

Strings kunnen ook worden gemaakt met de methode String.fromCharCode .

String.fromCharCode(104,101,108,108,111) //"hello"

Het creëren van een String-object met behulp van een new trefwoord is toegestaan, maar wordt niet aanbevolen omdat het zich gedraagt als objecten in tegenstelling tot primitieve strings.

var objectString = new String("Yes, I am a String object");
typeof objectString;//"object"
typeof objectString.valueOf();//"string"

Aaneengesloten snaren

String-aaneenschakeling kan worden gedaan met de + concatenation-operator of met de ingebouwde concat() -methode op het String-objectprototype.

var foo = "Foo";
var bar = "Bar";
console.log(foo + bar);        // => "FooBar"
console.log(foo + " " + bar);  // => "Foo Bar"

foo.concat(bar)            // => "FooBar"
"a".concat("b", " ", "d")  // => "ab d"

Tekenreeksen kunnen worden samengevoegd met niet-tekenreeksvariabelen, maar zullen de niet-tekenreeksvariabelen in tekenreeksen omzetten.

var string = "string";
var number = 32;
var boolean = true;

console.log(string + number + boolean); // "string32true"

String-sjablonen

var greeting = `Hello`;

var place = `World`;
var greet = `Hello ${place}!`

console.log(greet); // "Hello World!"

`a\\b` // =  a\b
String.raw`a\\b` // = a\\b

Ontsnappen aanhalingstekens

Als uw string tussen enkele aanhalingstekens staat (dat wil zeggen), moet u de letterlijke aanhalingstekens met backslash \

var text = 'L\'albero means tree in Italian';
console.log( text ); \\ "L'albero means tree in Italian"

Hetzelfde geldt voor dubbele aanhalingstekens:

var text = "I feel \"high\"";

Speciale aandacht moet worden besteed aan ontsnappende aanhalingstekens als u HTML-representaties binnen een string opslaat, omdat HTML-strings veel gebruik maken van citaten, dwz in attributen:

var content = "<p class=\"special\">Hello World!</p>";        // valid String
var hello   = '<p class="special">I\'d like to say "Hi"</p>'; // valid String

Citaten in HTML-tekenreeksen kunnen ook worden weergegeven met ' (of ' ) als een enkele quote en " (of " ) als dubbele aanhalingstekens.

var hi    = "<p class='special'>I'd like to say &quot;Hi&quot;</p>"; // valid String
var hello = '<p class="special">I&apos;d like to say "Hi"</p>';      // valid String

Opmerking: het gebruik van ' en " zal geen dubbele aanhalingstekens overschrijven die browsers automatisch op attribuutcitaten kunnen plaatsen. Bijvoorbeeld <p class=special> wordt gemaakt naar <p class="special"> , met behulp van " kan leiden tot <p class=""special""> waarbij \" <p class="special"> .

var x = `"Escaping " and ' can become very annoying`;

Omgekeerde string

De meest "populaire" manier om een string in JavaScript om te keren is het volgende codefragment, wat vrij gebruikelijk is:

function reverseString(str) {
    return str.split('').reverse().join('');
}

reverseString('string');    // "gnirts"

Dit zal echter alleen werken zolang de string die wordt omgekeerd geen surrogaatparen bevat. Astrale symbolen, dwz tekens buiten het basis meertalige vlak, kunnen worden weergegeven door twee code-eenheden en zullen ertoe leiden dat deze naïeve techniek verkeerde resultaten oplevert. Bovendien verschijnen tekens met combinatietekens (bijv. Diaerese) op het logische "volgende" teken in plaats van het oorspronkelijke teken waarmee het werd gecombineerd.

'𝌆■.'.split('').reverse().join(''); //fails

Hoewel de methode in de meeste talen goed werkt, is een echt nauwkeurige codering met respect voor algoritme voor stringomkering iets meer betrokken. Een dergelijke implementatie is een kleine bibliotheek genaamd Esrever , die reguliere expressies gebruikt voor het combineren van combinatietekens en surrogaatparen om het omkeren perfect uit te voeren.

Uitleg

Spreadoperator gebruiken

function reverseString(str) {
    return [...String(str)].reverse().join('');    
}

console.log(reverseString('stackoverflow'));  // "wolfrevokcats"
console.log(reverseString(1337));             // "7331"
console.log(reverseString([1, 2, 3]));        // "3,2,1"

Aangepaste reverse() functie

function reverse(string) {
    var strRev = "";
    for (var i = string.length - 1; i >= 0; i--) {
        strRev += string[i];
    }
    return strRev; 
}

reverse("zebra");  // "arbez"

Witruimte inkorten

Gebruik String.prototype.trim om witruimte vanaf de randen van een tekenreeks bij te String.prototype.trim :

"    some whitespaced string  ".trim();  // "some whitespaced string"

Veel JavaScript-engines, maar niet Internet Explorer , hebben niet-standaard trimLeft en trimRight methoden trimRight . Er is een voorstel , momenteel in fase 1 van het proces, voor gestandaardiseerde trimStart en trimEnd methoden, trimRight voor trimLeft en trimRight voor compatibiliteit.

// Stage 1 proposal
"    this is me    ".trimStart();  // "this is me    "
"    this is me    ".trimEnd();  // "    this is me"

// Non-standard methods, but currently implemented by most engines
"    this is me    ".trimLeft();  // "this is me    "
"    this is me    ".trimRight();  // "    this is me"

Substrings met plak

Gebruik .slice() om substrings te extraheren met twee indices:

var s = "0123456789abcdefg";
s.slice(0, 5);  // "01234"
s.slice(5, 6);  // "5"

Gegeven één index, duurt het van die index tot het einde van de string:

s.slice(10);    // "abcdefg"

Een string in een array splitsen

Gebruik .split om van strings naar een reeks gesplitste substrings te gaan:

var s = "one, two, three, four, five"
s.split(", ");  // ["one", "two", "three", "four", "five"]

Gebruik de array-methode .join om terug te gaan naar een string:

s.split(", ").join("--");  // "one--two--three--four--five"

Strings zijn unicode

Alle JavaScript-strings zijn unicode!

var s = "some ∆≈ƒ unicode ¡™£¢¢¢";
s.charCodeAt(5);  // 8710

JavaScript bevat geen onbewerkte byte of binaire tekenreeksen. Gebruik getypte matrices om binaire gegevens effectief te verwerken.

Een string detecteren

Om te detecteren of een parameter is een primitieve koord, gebruik typeof :

var aString = "my string";
var anInt = 5;
var anObj = {};
typeof aString === "string";   // true
typeof anInt === "string";     // false
typeof anObj === "string";     // false

Als je ooit een String object hebt, via new String("somestr") , werkt het bovenstaande niet. In dit geval kunnen we instanceof :

var aStringObj = new String("my string");
aStringObj instanceof String;    // true

Om beide instanties te dekken, kunnen we een eenvoudige helpfunctie schrijven:

var isString = function(value) {
    return typeof value === "string" || value instanceof String;
};

var aString = "Primitive String";
var aStringObj = new String("String Object");
isString(aString); // true
isString(aStringObj); // true
isString({}); // false
isString(5); // false

Of we kunnen gebruik maken van de toString functie van Object . Dit kan handig zijn als we ook op andere typen moeten controleren, bijvoorbeeld in een schakelinstructie, omdat deze methode ook andere gegevenstypen ondersteunt, net als typeof .

var pString = "Primitive String";
var oString = new String("Object Form of String");
Object.prototype.toString.call(pString);//"[object String]"
Object.prototype.toString.call(oString);//"[object String]"    

Een robuustere oplossing is om helemaal geen string te detecteren , maar alleen te controleren welke functionaliteit vereist is. Bijvoorbeeld:

var aString = "Primitive String";
// Generic check for a substring method
if(aString.substring) {

}
// Explicit check for the String substring prototype method
if(aString.substring === String.prototype.substring) {
    aString.substring(0, );
}

Strings Lexicografisch vergelijken

Gebruik localeCompare() om de tekenreeksen alfabetisch te vergelijken. Dit levert een negatieve waarde op als de referentiereeks lexicografisch (alfabetisch) vóór de vergeleken reeks (de parameter) staat, een positieve waarde als deze achteraf komt en een waarde van 0 als ze gelijk zijn.

var a = "hello";
var b = "world";

console.log(a.localeCompare(b)); // -1

De operatoren > en < kunnen ook worden gebruikt om tekenreeksen lexicografisch te vergelijken, maar ze kunnen geen waarde nul teruggeven (dit kan worden getest met de operator == gelijkheid). Als gevolg hiervan kan een vorm van de functie localeCompare() volgt worden geschreven:

function strcmp(a, b) {
    if(a === b) {
        return 0;
    }

    if (a > b) {
        return 1;
    }

    return -1;
}

console.log(strcmp("hello", "world")); // -1
console.log(strcmp("hello", "hello")); //  0
console.log(strcmp("world", "hello")); //  1

Dit is vooral handig wanneer u een sorteerfunctie gebruikt die vergelijkt op basis van het teken van de retourwaarde (zoals sort ).

var arr = ["bananas", "cranberries", "apples"];
arr.sort(function(a, b) {
    return a.localeCompare(b);
});
console.log(arr); // [ "apples", "bananas", "cranberries" ]

String naar hoofdletters

String.prototype.toUpperCase ():

console.log('qwerty'.toUpperCase()); // 'QWERTY'

Tekenreeks naar kleine letters

String.prototype.toLowerCase ()

console.log('QWERTY'.toLowerCase()); // 'qwerty'

Woordenteller

Stel dat u een <textarea> en informatie wilt opvragen over het aantal:

• Tekens (totaal)
• Tekens (geen spaties)
• Woorden
• lijnen

function wordCount( val ){
    var wom = val.match(/\S+/g);
    return {
        charactersNoSpaces : val.replace(/\s+/g, '').length,
        characters         : val.length,
        words              : wom ? wom.length : 0,
        lines              : val.split(/\r*\n/).length
    };
}


// Use like:
wordCount( someMultilineText ).words;   // (Number of words)

jsFiddle-voorbeeld

Toegang tot teken bij index in string

Gebruik charAt() om een teken op de opgegeven index in de tekenreeks te krijgen.

var string = "Hello, World!";
console.log( string.charAt(4) ); // "o"

Als alternatief, omdat tekenreeksen als arrays kunnen worden behandeld, gebruikt u de index via bracket-notatie .

var string = "Hello, World!";
console.log( string[4] ); // "o"

Gebruik charCodeAt() om de tekencode van het teken op een opgegeven index te krijgen.

var string = "Hello, World!";
console.log( string.charCodeAt(4) ); // 111

Merk op dat deze methoden allemaal getter-methoden zijn (retourneer een waarde). Tekenreeksen in JavaScript zijn onveranderlijk. Met andere woorden, geen van hen kan worden gebruikt om een karakter op een positie in de string te plaatsen.

String Zoek en vervang functies

Om naar een string in een string te zoeken, zijn er verschillende functies:

indexOf( searchString ) en lastIndexOf( searchString )

indexOf() retourneert de index van het eerste exemplaar van searchString in de tekenreeks. Als searchString niet wordt gevonden, wordt -1 teruggegeven.

var string = "Hello, World!";
console.log( string.indexOf("o") ); // 4
console.log( string.indexOf("foo") ); // -1

Op dezelfde manier retourneert lastIndexOf() de index van het laatste exemplaar van searchstring of -1 indien niet gevonden.

var string = "Hello, World!";
console.log( string.lastIndexOf("o") );   // 8
console.log( string.lastIndexOf("foo") ); // -1

includes( searchString, start )

includes() zal een boolean die aangeeft of terugkeren searchString bestaat in de string, beginnend bij index start (standaard 0). Dit is beter dan indexOf() als je gewoon moet testen op het bestaan van een substring.

var string = "Hello, World!";
console.log( string.includes("Hello") ); // true
console.log( string.includes("foo") );   // false

replace( regexp|substring, replacement|replaceFunction )

replace() een tekenreeks die alle voorkomens van substrings aanpassing heeft de terugkeer RegExp regexp of touw substring met een koord replacement of de geretourneerde waarde van replaceFunction .

Merk op dat dit de string niet op zijn plaats verandert, maar de string teruggeeft met vervangingen.

var string = "Hello, World!";
string = string.replace( "Hello", "Bye" );
console.log( string ); // "Bye, World!"

string = string.replace( /W.{3}d/g, "Universe" );
console.log( string ); // "Bye, Universe!"

replaceFunction kan worden gebruikt voor voorwaardelijke vervangingen voor reguliere expressieobjecten (bijv. bij gebruik met regexp ). De parameters zijn in deze volgorde:

Merk op dat alle parameters optioneel zijn.

var string = "heLlo, woRlD!";
string = string.replace( /([a-zA-Z])([a-zA-Z]+)/g, function(match, g1, g2) {
    return g1.toUpperCase() + g2.toLowerCase();
}); 
console.log( string ); // "Hello, World!"

Zoek de index van een substring in een string

De .indexOf methode retourneert de index van een substring binnen een andere string (indien aanwezig, of -1 indien anders)

'Hellow World'.indexOf('Wor');    // 7

.indexOf accepteert ook een extra numeriek argument dat aangeeft op welke index de functie moet beginnen te kijken

"harr dee harr dee harr".indexOf("dee", 10); // 14

Merk op dat .indexOf hoofdlettergevoelig is

 'Hellow World'.indexOf('WOR');    // -1

Tekenreeksrepresentaties van getallen

JavaScript heeft native conversie van Number naar zijn String-weergave voor elke base van 2 tot 36 .

De meest voorkomende weergave na decimaal (basis 10) is hexadecimaal (basis 16) , maar de inhoud van deze sectie werkt voor alle basen in het bereik.

Om een aantal van decimaal (basis 10) omzetten van het hexadecimaal (basis 16) tekenreeksweergave kan de methode toString worden met grondtal 16 .

// base 10 Number
var b10 = 12;

// base 16 String representation
var b16 = b10.toString(16); // "c"

Als het weergegeven getal een geheel getal is, kan de omgekeerde bewerking hiervoor worden uitgevoerd met parseInt en de radix 16 opnieuw

// base 16 String representation
var b16 = 'c';

// base 10 Number
var b10 = parseInt(b16, 16); // 12

Om een willekeurig getal (dat wil zeggen een niet-geheel getal) van de stringvoorstelling om te zetten in een getal , moet de bewerking in twee delen worden gesplitst; het gehele deel en het breukdeel.

let b16 = '3.243f3e0370cdc';
// Split into integer and fraction parts
let [i16, f16] = b16.split('.');

// Calculate base 10 integer part
let i10 = parseInt(i16, 16); // 3

// Calculate the base 10 fraction part
let f10 = parseInt(f16, 16) / Math.pow(16, f16.length); // 0.14158999999999988

// Put the base 10 parts together to find the Number
let b10 = i10 + f10; // 3.14159

Opmerking 1: Wees voorzichtig, aangezien kleine fouten in het resultaat kunnen voorkomen vanwege verschillen in wat mogelijk is om in verschillende bases te worden weergegeven. Het kan wenselijk zijn om achteraf een soort afronding uit te voeren.
Opmerking 2: Zeer lange weergaven van getallen kunnen ook leiden tot fouten vanwege de nauwkeurigheid en maximale waarden van Nummers van de omgeving waarin de conversies plaatsvinden.

Herhaal een string

"abc".repeat(3);  // Returns "abcabcabc"
"abc".repeat(0);  // Returns ""
"abc".repeat(-1); // Throws a RangeError

var myString = "abc";
var n = 3;

new Array(n + 1).join(myString);  // Returns "abcabcabc"

Karaktercode

De methode charCodeAt haalt de Unicode-tekencode van een enkel teken op:

var charCode = "µ".charCodeAt(); // The character code of the letter µ is 181

Om de karaktercode van een karakter in een string te krijgen, wordt de op 0 gebaseerde positie van het karakter doorgegeven als een parameter aan charCodeAt :

var charCode = "ABCDE".charCodeAt(3); // The character code of "D" is 68

// The Grinning Face Emoji has code point 128512 or 0x1F600
var codePoint = "😀".codePointAt();