@@ -10,6 +10,10 @@ import {
1010 parse
1111} from "./internal/string" ;
1212
13+ import {
14+ storeUnsafe as storeUnsafeArray
15+ } from "./internal/arraybuffer" ;
16+
1317@sealed
1418export class String {
1519
@@ -200,6 +204,7 @@ export class String {
200204 return compareUnsafe ( left , 0 , right , 0 , length ) <= 0 ;
201205 }
202206
207+ @inline
203208 includes ( searchString : String , position : i32 = 0 ) : bool {
204209 return this . indexOf ( searchString , position ) != - 1 ;
205210 }
@@ -400,14 +405,69 @@ export class String {
400405 throw new RangeError ( "Invalid count value" ) ;
401406 }
402407
403- if ( count === 0 || ! length ) return changetype < String > ( "" ) ;
404- if ( count === 1 ) return this ;
408+ if ( count == 0 || ! length ) return changetype < String > ( "" ) ;
409+ if ( count == 1 ) return this ;
405410
406411 var result = allocateUnsafe ( length * count ) ;
407412 repeatUnsafe ( result , 0 , this , count ) ;
408413 return result ;
409414 }
410415
416+ split ( separator : String = null , limit : i32 = i32 . MAX_VALUE ) : String [ ] {
417+ assert ( this !== null ) ;
418+ if ( ! limit ) return new Array < String > ( ) ;
419+ if ( separator === null ) return < String [ ] > [ this ] ;
420+ var length : isize = this . length ;
421+ var sepLen : isize = separator . length ;
422+ if ( limit < 0 ) limit = i32 . MAX_VALUE ;
423+ if ( ! sepLen ) {
424+ if ( ! length ) return new Array < String > ( ) ;
425+ // split by chars
426+ length = min < isize > ( length , < isize > limit ) ;
427+ let result = new Array < String > ( length ) ;
428+ let buffer = < ArrayBuffer > result . buffer_ ;
429+ for ( let i : isize = 0 ; i < length ; ++ i ) {
430+ let char = allocateUnsafe ( 1 ) ;
431+ store < u16 > (
432+ changetype < usize > ( char ) ,
433+ load < u16 > (
434+ changetype < usize > ( this ) + ( < usize > i << 1 ) ,
435+ HEADER_SIZE
436+ ) ,
437+ HEADER_SIZE
438+ ) ;
439+ storeUnsafeArray < String , String > ( buffer , i , char ) ;
440+ }
441+ return result ;
442+ } else if ( ! length ) {
443+ return < String [ ] > [ changetype < String > ( "" ) ] ;
444+ }
445+ var result = new Array < String > ( ) ;
446+ var end = 0 , start = 0 , i = 0 ;
447+ while ( ( end = this . indexOf ( separator , start ) ) != - 1 ) {
448+ let len = end - start ;
449+ if ( len > 0 ) {
450+ let out = allocateUnsafe ( len ) ;
451+ copyUnsafe ( out , 0 , this , start , len ) ;
452+ result . push ( out ) ;
453+ } else {
454+ result . push ( changetype < String > ( "" ) ) ;
455+ }
456+ if ( ++ i == limit ) return result ;
457+ start = end + sepLen ;
458+ }
459+ if ( ! start ) return < String [ ] > [ this ] ;
460+ var len = length - start ;
461+ if ( len > 0 ) {
462+ let out = allocateUnsafe ( len ) ;
463+ copyUnsafe ( out , 0 , this , start , len ) ;
464+ result . push ( out ) ;
465+ } else {
466+ result . push ( changetype < String > ( "" ) ) ;
467+ }
468+ return result ;
469+ }
470+
411471 toString ( ) : String {
412472 return this ;
413473 }
0 commit comments