JavaScript
strängar

Syntax

• "string letteral"
• "sträng bokstavligen"
• "strängbokstavligt med" felaktiga anpassningstecken "" // inga fel; citat är olika.
• "strängbokstavligt med" undgått citat "" // inga fel; offerter undviks.
• `mallsträng $ {expression}`
• String ("ab c") // returnerar strängen när den anropas i icke-konstruktörs sammanhang
• new String ("ab c") // String-objektet, inte strängen primitiv

Grundläggande information och sammankoppling av strängar

Strängar i JavaScript kan bifogas i enkla citat 'hello' , dubbla citat "Hello" och (från ES2015, ES6) i malllitteraler ( baksida ) `hello` .

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

Strängar kan skapas från andra typer med funktionen String() .

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

Eller, toString() kan användas för att konvertera siffror, booleaner eller objekt till strängar.

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

Strängar kan också skapas med hjälp String.fromCharCode metoden String.fromCharCode .

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

Att skapa ett strängobjekt med new nyckelord är tillåtet, men rekommenderas inte eftersom det beter sig som objekt till skillnad från primitiva strängar.

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

Slå samman strängar

Strängkoppling kan göras med + sammankopplingsoperatören eller med den inbyggda concat() -metoden på prototypen String-objekt.

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"

Strängar kan sammanlänkas med icke-strängvariabler men typkonverterar icke-strängvariablerna till strängar.

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

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

Strängmallar

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

Avsläppande offert

Om din sträng är omsluten (dvs.) i enstaka citat måste du undkomma den inre bokstavliga offerten med backslash \

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

Samma sak gäller dubbla citat:

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

Särskild uppmärksamhet måste ägnas åt att komma undan citat om du lagrar HTML-representationer i en sträng, eftersom HTML-strängar använder sig av citat, dvs i attribut:

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

Citat i HTML-strängar kan också representeras med ' (eller ' ) som en enda offert och " (eller " ) som dubbla citat.

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

Obs! Användningen av ' och " kommer inte att skriva över dubbla citat som webbläsare automatiskt kan placera på attributcitationstecken. Till exempel <p class=special> görs till <p class="special"> med " kan leda till <p class=""special""> där \" kommer att vara <p class="special"> .

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

Omvänd sträng

Det mest "populära" sättet att vända en sträng i JavaScript är följande kodfragment, vilket är ganska vanligt:

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

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

Detta kommer dock att fungera bara så länge strängen som vänds inte innehåller surrogatpar. Astralsymboler, dvs tecken utanför det grundläggande flerspråkiga planet, kan representeras av två kodenheter, och kommer att leda denna naiva teknik till att ge fel resultat. Dessutom kommer tecken med kombinerande markeringar (t.ex. diarrese) att visas på det logiska "nästa" karaktär istället för det ursprungliga som det kombinerades med.

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

Medan metoden fungerar bra för de flesta språk, är en riktigt noggrann kodning som respekterar algoritmen för snörvändning något mer involverad. En sådan implementering är ett litet bibliotek som heter Esrever , som använder regelbundna uttryck för att matcha kombinationer av märken och surrogatpar för att utföra vändningen perfekt.

Förklaring

Använda spridningsoperatör

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"

Anpassad reverse() -funktion

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

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

Trimma mellanrum

String.prototype.trim från kanterna på en sträng:

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

Många JavaScript-motorer, men inte Internet Explorer , har implementerat icke-standardiserade trimLeft och trimRight metoder. Det finns ett förslag , för närvarande på steg 1 i processen, för standardiserade trimStart och trimEnd metoder, anpassade till trimLeft och trimRight för kompatibilitet.

// 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"

Underlag med skiva

Använd .slice() att extrahera underlag med två index:

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

Med ett index kommer det att ta från det indexet till slutet av strängen:

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

Dela upp en sträng i en matris

Använd .split att gå från strängar till en rad delade underlag:

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

Använd array-metoden .join att gå tillbaka till en sträng:

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

Strängar är unicode

Alla JavaScript-strängar är unicode!

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

Det finns inga råa byte- eller binära strängar i JavaScript. För att effektivt hantera binära data använder du Typed Arrays .

Upptäcker en sträng

För att upptäcka om en parameter är en primitiv sträng, använd typeof :

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

Om du någonsin har ett String objekt via new String("somestr") , fungerar ovanstående inte. I det här fallet kan vi använda instanceof :

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

För att täcka båda fallen kan vi skriva en enkel hjälpfunktion:

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

Eller så kan vi använda toString av toString funktionen för Object . Detta kan vara användbart om vi måste kontrollera om det finns andra typer och även säga i ett switch-uttalande, eftersom denna metod stöder andra datatyper också precis som 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]"    

En mer robust lösning är att inte upptäcka en sträng alls, utan bara kontrollera om vilken funktionalitet som krävs. Till exempel:

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, );
}

Jämför strängar Lexikografiskt

localeCompare() att jämföra strängar alfabetiskt. Detta ger ett negativt värde om referenssträngen är lexikografiskt (alfabetiskt) före den jämförda strängen (parametern), ett positivt värde om det kommer efteråt och ett värde på 0 om de är lika.

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

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

Operatörerna > och < kan också användas för att jämföra strängar leksikografiskt, men de kan inte returnera ett värde på noll (detta kan testas med == jämställdhetsoperatören). Som ett resultat kan en form av localeCompare() skrivas så:

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

Detta är särskilt användbart när du använder en sorteringsfunktion som jämför baserat på tecken på returvärdet (som sort ).

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

Sträng till versaler

String.prototype.toUpperCase ():

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

Sträng till gemener

String.prototype.toLowerCase ()

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

Ordräknare

Säg att du har en <textarea> och att du vill hämta information om antalet:

• Tecken (totalt)
• Tecken (inga mellanslag)
• Ord
• Rader

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-exempel

Åtkomsttecken vid index i sträng

Använd charAt() att få ett tecken på det angivna indexet i strängen.

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

Alternativt, eftersom strängar kan behandlas som matriser, använd indexet via konsolnotation .

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

charCodeAt() att få karaktärens teckenkod vid ett specificerat index.

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

Observera att dessa metoder alla är getter-metoder (returnera ett värde). Strängar i JavaScript är oföränderliga. Med andra ord, ingen av dem kan användas för att ställa in ett tecken på en position i strängen.

Sträng Hitta och ersätt funktioner

För att söka efter en sträng i en sträng finns det flera funktioner:

indexOf( searchString ) och lastIndexOf( searchString )

indexOf() returnerar indexet för den första förekomsten av searchString i strängen. Om searchString inte hittas, returneras -1 .

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

På liknande sätt lastIndexOf() indexet för den senaste förekomsten av searchstring eller -1 om den inte hittades.

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

includes( searchString, start )

includes() kommer att returnera en boolesk som berättar huruvida searchString existerar i strängen, med början från index start (standard är 0). Detta är bättre än indexOf() om du helt enkelt behöver testa att det finns en substring.

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

replace( regexp|substring, replacement|replaceFunction )

replace() returnerar en sträng som har alla förekomster av delsträngar som matchar RegExp regexp eller sträng substring med en sträng replacement eller returnerade värdet av replaceFunction .

Observera att detta inte modifierar strängen på plats utan returnerar strängen med ersättningar.

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 användas för villkorliga ersättningar för reguljära uttrycksobjekt (dvs med användning av regexp ). Parametrarna är i följande ordning:

Observera att alla parametrar är valfria.

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!"

Hitta indexet för en substring i en sträng

Metoden .indexOf returnerar indexet för en substring i en annan sträng (om det finns, eller -1 om annat)

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

.indexOf accepterar också ett ytterligare numeriskt argument som anger på vilket index ska funktionen börja titta

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

Observera att .indexOf är skiftlägeskänsligt

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

Strängrepresentationer av siffror

JavaScript har inbyggd konvertering från Number to its String representation för alla baser från 2 till 36 .

Den vanligaste representationen efter decimal (bas 10) är hexadecimal (bas 16) , men innehållet i detta avsnitt fungerar för alla baser i intervallet.

För att omvandla ett nummer från decimal (bas 10) till det hexadecimala (bas 16) strängbeteckning toString metoden kan användas med radix 16 .

// base 10 Number
var b10 = 12;

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

Om det representerade numret är ett heltal kan den omvända operationen för detta göras med parseInt och radix 16 igen

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

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

För att konvertera ett godtyckligt tal (dvs icke-heltal) från sin strängrepresentation till ett nummer måste operationen delas upp i två delar; heltal och bråkdel.

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

Obs 1: Var försiktig eftersom små fel kan vara i resultatet på grund av skillnader i vad som är möjligt att representeras i olika baser. Det kan vara önskvärt att utföra någon slags avrundning efteråt.
Not 2: Väldigt lång representationer av siffror kan också resultera i fel på grund av noggrannhets och maxvärden för Numbers miljö omräkningarna sker i.

Upprepa en sträng

"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"

Teckenkod

Metoden charCodeAt hämtar Unicode-teckenkoden för ett enda tecken:

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

För att få teckenkoden för ett tecken i en sträng, skickas charCodeAt 0-baserade position som en parameter till 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();