JavaScript1

UTF-16

:

let single = 'single-quoted';
let double = "double-quoted";

let backticks = `backticks`;

function sum(a, b) {
  return a + b;
}

alert(`1 + 2 = ${sum(1, 2)}.`); // 1 + 2 = 3.

:

let guestList = `Guests:
 * John
 * Pete
 * Mary
`;

alert(guestList); // 

:

let guestList = "Guests:  // Error: Unexpected token ILLEGAL
  * John";

:func`string` func docs

\n

let guestList = "Guests:\n * John\n * Pete\n * Mary";

alert(guestList); // 

2:

let str1 = "Hello\nWorld"; // "" 

// 
let str2 = `Hello
World`;

alert(str1 == str2); // true

:

:

alert( "\u00A9" ); // 
alert( "\u{20331}" ); // ,  (long unicode)
alert( "\u{1F60D}" ); // ,  (another long unicode)

\

:

alert( 'I\'m the Walrus!' ); // I'm the Walrus!

\'

:

alert( `I'm the Walrus!` ); // I'm the Walrus!

\ JavaScript \ alert

\

\\ 2:

alert( `The backslash: \\` ); // The backslash: \

length :

alert( `My\n`.length ); // 3

\n 1 3

pos [pos] str.charAt(pos) 0 :

let str = `Hello`;

// 
alert( str[0] ); // H
alert( str.charAt(0) ); // H

// 
alert( str[str.length - 1] ); // o

charAt

[] undefined charAt

let str = `Hello`;

alert( str[1000] ); // undefined
alert( str.charAt(1000) ); // '' ()

for..of :

for (let char of "Hello") {
  alert(char); // H,e,l,l,o ( "H",  "e",  "l" ... )
}

JavaScript

:

let str = 'Hi';

str[0] = 'h'; // 
alert( str[0] ); // 

str

:

let str = 'Hi';

str = 'h' + str[1];  // 

alert( str ); // hi

()

toLowerCase() toUpperCase() :

alert( 'Interface'.toUpperCase() ); // INTERFACE
alert( 'Interface'.toLowerCase() ); // interface

1:

alert( 'Interface'[0].toLowerCase() ); // 'i'

str.indexOf

str.indexOf(substr, pos)

str substr pos -1

:

let str = 'Widget with id';

alert( str.indexOf('Widget') ); // 0, 'Widget' 
alert( str.indexOf('widget') ); // -1, 

alert( str.indexOf("id") ); // 1, "id"  1 (..idget  id)

2

"id" 1 2 :

let str = 'Widget with id';

alert( str.indexOf('id', 2) ) // 12

indexOf :

let str = 'As sly as a fox, as strong as an ox';

let target = 'as'; // 

let pos = 0;
while (true) {
  let foundPos = str.indexOf(target, pos);
  if (foundPos == -1) break;

  alert( `Found at ${foundPos}` );
  pos = foundPos + 1; // 
}

:

let str = "As sly as a fox, as strong as an ox";
let target = "as";

let pos = -1;
while ((pos = str.indexOf(target, pos + 1)) != -1) {
  alert( pos );
}

if indexOf if :

let str = "Widget with id";

if (str.indexOf("Widget")) {
    alert("We found it"); // 
}

alert str.indexOf("Widget") 0 ()if 0 false

-1 :

let str = "Widget with id";

if (str.indexOf("Widget") != -1) {
    alert("We found it"); // !
}

The bitwise NOT trick

1 ~ bitwise NOT 32bit ()2

32 n IEEE-754 -(n+1)

:

alert( ~2 ); // -3, -(2+1) 
alert( ~1 ); // -2, -(1+1) 
alert( ~0 ); // -1, -(0+1) 
alert( ~-1 ); // 0, -(-1+1) 

~n n == -1

if ( ~str.indexOf("...") ) indexOf -1 true

indexOf :

let str = "Widget";

if (~str.indexOf("Widget")) {
  alert( 'Found it!' ); // 
}

: if (~str.indexOf(...))

~ 320 ~4294967295=0

JavaScript .includes

includes, startsWith, endsWith

str.includes(substr, pos) str substr true/false

alert( "Widget with id".includes("Widget") ); // true

alert( "Hello".includes("Bye") ); // false

str.includes 2:

alert( "Midget".includes("id") ); // true
alert( "Midget".includes("id", 3) ); // false,  3 "id" 

str.startsWith str.endsWith :

alert( "Widget".startsWith("Wid") ); // true, "Widget"  "Wid" 
alert( "Widget".endsWith("get") );   // true, "Widget"  "get" 

JavaScript3: substring, substr slice

str.slice(start [, end])

start end ()

:

let str = "stringify";
alert( str.slice(0, 5) ); // 'strin', 0  5  (5)
alert( str.slice(0, 1) ); // 's', 0  1,  1  0 

2slice :

let str = "stringify";
alert( str.slice(2) ); // ringify, 2

start/end :

let str = "stringify";

// 41
alert( str.slice(-4, -1) ); // gif

str.substring(start [, end])

start end

slice start end

:

let str = "stringify";

// 
alert( str.substring(2, 6) ); // "ring"
alert( str.substring(6, 2) ); // "ring"

// ...slice :
alert( str.slice(2, 6) ); // "ring" ()
alert( str.slice(6, 2) ); // "" ()

slice 0

str.substr(start [, length])

start length

length :

let str = "stringify";
alert( str.substr(2, 4) ); // ring, 2 4

:

let str = "stringify";
alert( str.substr(-4, 2) ); // gi, 4 2

:

1. :

   alert( 'a' > 'Z' ); // true

2. :

   alert( 'sterreich' > 'Zealand' ); // true

   sterreich Zealand

JavaScript

UTF-16

str.codePointAt(pos)

pos :

// 
alert( "z".codePointAt(0) ); // 122
alert( "Z".codePointAt(0) ); // 90

String.fromCodePoint(code)

code :

alert( String.fromCodePoint(90) ); // Z

\ 16:

// 90  16 5a 
alert( '\u005a' ); // Z

65..220 ():

let str = '';

for (let i = 65; i <= 220; i++) {
  str += String.fromCodePoint(i);
}
alert( str );
// ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
// 

a > Z

a (97) Z (90)

• a z

(IE10 Intl.JS ) ECMA 402

str.localeCompare(str2) :

• str str2 1
• str str2 -1
• 0

:

alert( 'sterreich'.localeCompare('Zealand') ); // -1

the documentation 2()"a" "a"

, Unicode

2 2

2 65536 2

2 :

alert( ''.length ); // 2, MATHEMATICAL SCRIPT CAPITAL X
alert( ''.length ); // 2, FACE WITH TEARS OF JOY
alert( ''.length ); // 2, a rare chinese hieroglyph

JavaScript!

1length 2

String.fromCodePoint str.codePointAt String.fromCharCode str.charCodeAt fromCodePoint/codePointAt

2:

alert( ''[0] ); // ...
alert( ''[1] ); // ...

alert

: 0xd800..0xdbff (2) 0xdc00..0xdfff

:

// charCodeAt 

alert( ''.charCodeAt(0).toString(16) ); // d835, 0xd800  0xdbff 
alert( ''.charCodeAt(1).toString(16) ); // dcb3, 0xdc00  0xdfff 

/

a UTF-16

UTF-16 1

S \u0307 S

alert( 'S\u0307' ); // S

()

( \u0323) S: S

:

alert( 'S\u0307\u0323' ); // S

: 2

:

let s1 = 'S\u0307\u0323'; // S, S +  + 
let s2 = 'S\u0323\u0307'; // S, S +  + 

alert( `s1: ${s1}, s2: ${s2}` );

alert( s1 == s2 ); // false 

1

str.normalize()

alert( "S\u0307\u0323".normalize() == "S\u0323\u0307".normalize() ); // true

normalize() 31 \u1e68 (S 2)

alert( "S\u0307\u0323".normalize().length ); // 1

alert( "S\u0307\u0323".normalize() == "\u1e68" ); // true

S UTF-16

Unicode Normalization Forms

• 3
• JavaScript UTF-16
• \n \u...
• []
• slice substring
• /toLowerCase/toUpperCase
• indexOf includes/startsWith/endsWith
• localeCompare

:

• str.trim()
• str.repeat(n) n
• manual

/