z-str

A lib to easily manipulate strings

Installation

  npm i z-str

Usage

Javascript

  const { ZStr } = require('z-str');

  const myString = 'aBcdefg dgf dxf';
  const str = new ZStr(myString, {caseSensitive: false});

  console.log(str.from('a').till('e').toString()); //Bcd
  console.log(str.fromLast('d').tillLast('f').toString()); //x
  console.log(str.startsWith('abc')); //true
  console.log(str.search('b').next());
  console.log(str.batch().from('d').till('f').split().list().asStringArray()); //['e', 'g', 'x']

Typescript

  import { ZStr } from 'z-str';

  const myString = 'aBcdefg dgf dxf';
  const str = new ZStr(myString, {caseSensitive: false});

  console.log(str.from('a').till('e').toString()); //Bcd
  console.log(str.fromLast('d').tillLast('f').toString()); //x
  console.log(str.startsWith('abc')); //true
  console.log(str.search('b').next());
  console.log(str.batch().from('d').till('f').split().list().asStringArray()); //['e', 'g', 'x']

Summary

Constructor isEmpty sub equals substr substring containsAny containsAll findFirst findLast from fromLast till tillLast startsWith endsWith batch fromIndex tillIndex split trim trimStart trimEnd

Constructor

  new ZStr(string, options);

Default values of options:

  {
    caseSensitive: true,
    inclusive: false,
    ignoreErrors: false
  }

Is empty

  str.isEmpty(): boolean;

  console.log(new ZStr('').isEmpty()); //true
  console.log(new ZStr('abc').isEmpty()); //false

Sub

Create a new ZStr with other options:

  str.sub(options): ZStr;

  const str = new ZStr('Abc');
  const sub = str.sub({caseSensitive: false});

  console.log(str.equals('abc')); //false
  console.log(sub.equals('abc')); //true

Equals

Compare two strings

  str.equals(otherString: string | ZStr): boolean;

  const a = new ZStr('a');
  const b = new ZStr('A', {caseSensitive: false});

  console.log(a.equals('a')); //true
  console.log(a.equals('A')); //false

  console.log(b.equals('a')); //true
  console.log(b.equals('A')); //true
  
  console.log(a.equals(b)); //false
  console.log(b.equals(a)); //true

Search

  str.search(patterns: string|string[], patternsToIgnore?: string[]): ZStrSearch;

Example 1

  const source = 'Name: Edward; Age:: 15';
  const search = new ZStr(source).search(':');
  const results = search.list();
  console.log(results);

Output

  [
    {
      start: 4,
      end: 5,
      pattern: ':',
      valid: true,
      getFoundPattern: [Function]
    },
    {
      start: 17,
      end: 18,
      pattern: ':',
      valid: true,
      getFoundPattern: [Function]
    },
    {
      start: 18,
      end: 19,
      pattern: ':',
      valid: true,
      getFoundPattern: [Function]
    }
  ]

Example 2

  const source = 'Name: Edward; Age:: 15';
  const search = new ZStr(source).search([':'], ['::']);
  const results = search.list();
  console.log(results);

Output

  [
    {
      start: 4,
      end: 5,
      pattern: ':',
      valid: true,
      getFoundPattern: [Function]
    }
  ]

Example 3

  const source = 'Name: Edward; Age:: 15';
  const search = new ZStr(source).search([':'], ['::']);
  while (search.hasNext()){
    console.log(search.next().start);
  }

Output

  4

Example 4 - com reverseDirection()

  const source = 'Name: Edward; Age:: 15';
  const search = new ZStr(source).search([':']);
  search.reverseDirection();
  while (search.hasNext()){
    console.log(search.next().start);
  }

Output

  18
  17
  4

Substr

str.substr(start: number, length?: number): ZStr;

  const str = new ZStr('abcdef');
  console.log(str.substr(3, 1).toString()); //d

Substring

str.substring(start: number, end?: number): ZStr;

  const str = new ZStr('abcdef');
  console.log(str.substring(3, 5)).toString(); //de

Contains any

str.containsAny(patterns: string | string[], patternsToIgnore: string[]): boolean;

  const str = new ZStr('abc');

  console.log(str.containsAny(['e','a'])); //true
  console.log(str.containsAny(['e','f'])); //false

Contains all

str.containsAll(patterns: string | string[], patternsToIgnore: string[]): boolean;

  const str = new ZStr('abc');

  console.log(str.containsAll(['b','a'])); //true
  console.log(str.containsAll(['a','e'])); //false

Find first

str.findFirst(patterns: string|string[], patternsToIgnore: string[]): ZStrSearchResult;

  const str = new ZStr('abc:def:ghi');

  console.log(str.findFirst([':'])); 

Output:

  {
    start: 3,
    end: 4,
    pattern: ':',
    valid: true,
    getFoundPattern: [Function]
  }

Don't found

Example:

  const str = new ZStr('abc:def:ghi');

  console.log(str.findFirst(['::'])); 

Output:

  {
    start: 0,
    end: 0,
    pattern: '',
    valid: false,
    getFoundPattern: [Function: getFoundPattern]
  }

Find last

str.findLast(patterns: string|string[], patternsToIgnore: string[]): ZStrSearchResult;

  const str = new ZStr('abc:def:ghi');

  console.log(str.findLast([':'])); 

Output:

  {
    start: 7,
    end: 8,
    pattern: ':',
    valid: true,
    getFoundPattern: [Function]
  }

From

str.from(patterns: string|string[], patternsToIgnore: string[]): ZStr;

Example 1

  const str = new ZStr('abc->def<-ghi');

  console.log(str.from('->').toString())); //def<-ghi

Example 2

  const str = new ZStr('abc->def<-ghi', {inclusive: true});

  console.log(str.from('->').toString())); //->def<-ghi

From last

str.fromLast(patterns: string|string[], patternsToIgnore: string[]): ZStr;

  const str = new ZStr('abc->->def<-ghi');

  console.log(str.fromLast('->').toString())); //def<-ghi

Till

str.till(patterns: string|string[], patternsToIgnore: string[]): ZStr;

Example 1

  const str = new ZStr('abc->def<-<-ghi');

  console.log(str.till('<-').toString())); //abc->def

Example 2

  const str = new ZStr('abc->def<-<-ghi', {inclusive: true});

  console.log(str.till('<-').toString())); //abc->def<-

Till last

tr.tillLast(patterns: string|string[], patternsToIgnore: string[]): ZStr;

  const str = new ZStr('abc->def<-<-ghi', {inclusive: true});

  console.log(str.tillLast('<-').toString())); //abc->def<-<-

Starts with

tr.startsWith(patterns: string|string[], patternsToIgnore: string[]): ZStr;

  const str = new ZStr('aBcdEf');

  console.log(str.startsWith('aBc')); //true
  console.log(str.startsWith(['eFg','aBc'])); //true
  console.log(str.startsWith('abc')); //false
  console.log(str.sub({caseSensitive: false}).startsWith('abc')); //true

Ends with

str.endsWith(patterns: string|string[], patternsToIgnore: string[]): ZStr;

  const str = new ZStr('aBcdEf');

  console.log(str.endsWith('Ef')); //true
  console.log(str.endsWith(['zzz','dEf'])); //true
  console.log(str.endsWith('def')); //false
  console.log(str.sub({caseSensitive: false}).endsWith('def')); //true

Batch

  str.batch(): ZStrBatch;

  const str = new ZStr('Name: Edward; Age: 20; Name: Maria; Age: 25');

  const names1 = str.batch().from("Name: ").till(";").split().asStringArray();

  const names2 = str.batch().caseSensitive(false).from("name:").inclusive().till(";").split().list().trim().asStringArray();

  console.log(names1); //['Edward', 'Maria']
  console.log(names2); //['Edward;', 'Maria;']
)

  const str = new ZStr('Name: Edward; Age: 20; Name: Maria; Age: 25');

  const persons = str.batch().from('Name:').till(';').trim().name('name').from('Age:').till(';').trim().name('age').group().list();

  console.log(persons); //[{name: 'Edward', age: '20'}, {name: 'Maria', age: '25'}]

From index

  str.fromIndex(index: number): ZStr;

  const str = new ZStr('123Abc');

  console.log(str.fromIndex(3).toString()); //Abc
  console.log(str.fromIndex(-2).toString()); //bc

Till index

  str.tillIndex(index: number): ZStr;

  const str = new ZStr('123Abc');

  console.log(str.tillIndex(3).toString()); //123
  console.log(str.tllIndex(-2).toString()); //123A

Split

  str.split(patterns: string | string[], pattersToIgnore?: string[]): ZStrSplitter;

  const str = new ZStr('Edward,Maria;Sarah');

  console.log(str.split([',',';']).asStringArray())); //['Edward', 'Maria', 'Sarah']

Trim

  str.trim(): ZStr;

Trim start

  str.trimStart(): ZStr;

Trim end

  str.trimEnd(): ZStr;