Javascript split

Daemon потоки non-daemon

До этого момента примеры программ ожидали, пока все потоки не завершат свою работу. Иногда программы порождают такой поток, как демон. Он работает, не блокируя завершение основной программы.

Использование демона полезно, если не удается прервать поток или завершить его в середине работы, не потеряв и не повредив при этом данные.

Чтобы пометить поток как demon, вызовите метод setDaemon() с логическим аргументом. По умолчанию потоки не являются «демонами», поэтому передача в качестве аргумента значения True включает режим demon.

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

Обратите внимание, что в выводимых данных отсутствует сообщение «Exiting» от потока-демона. Все потоки, не являющиеся «демонами» (включая основной поток), завершают работу до того, как поток-демон выйдет из двухсекундного сна

$ python threading_daemon.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting

Чтобы дождаться завершения работы потока-демона, используйте метод join().

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join()
t.join()

Метод join() позволяет demon вывести сообщение «Exiting».

$ python threading_daemon_join.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting
(daemon    ) Exiting

Также можно передать аргумент задержки (количество секунд, в течение которых поток будет неактивным).

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join(1)
print 'd.isAlive()', d.isAlive()
t.join()

Истекшее время ожидания меньше, чем время, в течение которого поток-демон спит. Поэтому поток все еще «жив» после того, как метод join() продолжит свою работу.

$ python threading_daemon_join_timeout.py

(daemon    ) Starting
(non-daemon) Starting
(non-daemon) Exiting
d.isAlive() True

# API

Options

Options	Description
	An optional list of elements or a css selector. By default, this is
	The splitting plugin to use. See the plugin page for a full list. If not specified, the value of the data-splitting attribute will be use. If that is not present, the plugin will be used.
	An optional key used as a prefix on on CSS Variables. For instance when a key of is used with the plugin, it will changethe CSS variable to . This should be used if multiple splits have been performed on the same element, or to resolve conflicts with other libraries.

Plugin-specific Options

Options	Description
	Used by the following plugins to select children to index: , , , , , , and . If not specified, the immediate child elements will be selected.
	The number of columns to create or detect. This is used by the following plugins: , , , and
	The number of rows to create or detect. This is used by the following plugins: , , , and
	If true, the plugin will count whitespace while indexing characters.

Returns

The fucntion always returns an array of objects with the following properties based on plugin name, giving you access to each element’s splits to use with JavaScript animation libraries or for additional processing.

Property	Type	Description
		An array of all characters created by the plugin
		An array of all words created by the and plugin
		An array of element arrays by the line, returned by the plugin
		An array of elements returned by the plugin.
		An array of element arrays by row, returned by the and plugin
		An array of element arrays by column, returned by the and plugin
		An array of cells created by , , or plugin
		An array of element arrays by the row, returned by the and plugin
		An array of element arrays by the column, returned by the and plugin

The function takes the same options as but has a required property of . The property should be an html string to be used as the splitting target. The function returns a string of the rendered HTML instead of returning a result object. This function is intended to be used inside of JS Framework DSL’s such as the Vue templating language:

Options	Description
	The name of the plugin. It must be unique.
	The prefix to set when adding index/total css custom properties to the elements.
	The function to call when this plugin is used. The return value is set in the result of as the same name as the in the plugin.
	The plugins that must run prior to this plugin.

Сигналы между потоками

Бывают случаи, когда нужно синхронизировать операции в двух или более потоках. Простой способ реализации – использование объектов Event.

Event управляет внутренним флагом, который вызывающий объект может либо устанавливать (set()) либо сбрасывать (clear()). Другие потоки могут ждать (wait()), пока флаг не будет установлен (set()),блокируя процесс, пока не будет разрешено продолжить выполнение.

import logging
import threading
import time

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )
                    
def wait_for_event(e):
    """Wait for the event to be set before doing anything"""
    logging.debug('wait_for_event starting')
    event_is_set = e.wait()
    logging.debug('event set: %s', event_is_set)

def wait_for_event_timeout(e, t):
    """Wait t seconds and then timeout"""
    while not e.isSet():
        logging.debug('wait_for_event_timeout starting')
        event_is_set = e.wait(t)
        logging.debug('event set: %s', event_is_set)
        if event_is_set:
            logging.debug('processing event')
        else:
            logging.debug('doing other work')


e = threading.Event()
t1 = threading.Thread(name='block', 
                      target=wait_for_event,
                      args=(e,))
t1.start()

t2 = threading.Thread(name='non-block', 
                      target=wait_for_event_timeout, 
                      args=(e, 2))
t2.start()

logging.debug('Waiting before calling Event.set()')
time.sleep(3)
e.set()
logging.debug('Event is set')

Метод wait() принимает время задержки. Он возвращает логическое значение, указывающее, установлено событие или нет. Поэтому вызывающий объект знает, почему был возвращен wait(). Метод isSet() можно использовать для события отдельно, не опасаясь блокировки.

В этом примере wait_for_event_timeout() проверяет состояние события без бесконечной блокировки. wait_for_event() блокирует вызов wait(), который не возобновляет свою работу до изменения статуса события.

$ python threading_event.py

(block     ) wait_for_event starting
(non-block ) wait_for_event_timeout starting
(MainThread) Waiting before calling Event.set()
(non-block ) event set: False
(non-block ) doing other work
(non-block ) wait_for_event_timeout starting
(MainThread) Event is set
(block     ) event set: True
(non-block ) event set: True
(non-block ) processing event

slice()

Метод  копирует заданную часть массива и возвращает её в виде совершенно нового массива. Этот метод вообще не трогает оригинальный массив:

From: с индекса какого элемента начинается нарезка массива

Until: до какого элемента массива нарезается массив

Для примера, нам нужно нарезать первые три элемента из вышеуказанного массива. Так как первый элемент в массиве всегда имеет индекс 0, то начнём мы нарезку именно с него.

А теперь хитрый момент. Когда мне надо нарезать первые три элемента, мне надо задать параметр . Почему? Потому что  не затрагивает последний заданный элемент.

Это может создать некое недопонимание. Именно по этому я назвал второй параметр  (до).

И наконец, я назначаю нарезанный массив на переменную . Давайте посмотрим, что получается:

Важное замечание: метод  также можно использовать и на строках

Встроенные функции строк в Python

В арсенале Python есть несколько функций, которые могут использоваться вместе с данными типа «строки».

chr(). Превращает целочисленное значение в символьное.

ord(). Осуществляет противоположное действие. То есть, из символьного типа делает целочисленное значение.

len(). Позволяет получить длину строки. 

1. Превращает любой объект в строчное значение.

Конечно, этого краткого описания недостаточно. Поэтому рассмотрим каждый из них более подробно.

Функция ord(d)

Используется для получения числового значения для символа. Здесь, чтобы разобраться, необходимо понять следующее: в любой операционной системе каждому символу, независимо от того, это буква или знак, соответствует определенный порядковый номер. 

Например, таблицей латинских символов является ASCII. С ними программисты работают чаще всего, поэтому мы приведем два примера с тем, как работает это на практике.

>>> ord(‘a’)

97

>>> ord(‘#’)

35

Но поскольку прошлый вариант был самым простым, сейчас есть более мощные стандарты, охватывающие самые разные языки. Python 3 версии поддерживает все возможные языки, и каждый из них имеет свой диапазон числовых представлений. Поэтому в качестве аргумента этой функции можно передавать любое значение, независимо от того, это буква определенного алфавита или определенный знак. Например, можно получить числовое представление следующих символов.

>>> ord(‘€’)

8364

>>> ord(‘∑’)

8721

Функция chr(d)

Как уже писалось выше, эта функция выполняет полностью противоположные действия. То есть, она ищет значение в таблице символов, которое соответствует тому числу, которое программист или пользователь передаст ей в качестве аргумента.

Эта функция также может работать не только с ASCII-таблицей, но и Юникодом.

>>> chr(8364)

‘€’

>>> chr(8721)

‘∑’

Функция len(s)

С помощью этой функции пользователь может определить количество символов, которые входят в определенную строку.

>>> s = ‘Простая строка.’

>>> len(s)

15

Функция str(x)

С ее помощью можно получить объект в виде строки. В языке Python почти нет объектов, которые нельзя было бы выразить в строчном виде. Ну и приведем фрагмент кода, как это используется на практике.

>>> str(49.2)

‘49.2’

>>> str(3+4j)

‘(3+4j)’

>>> str(3 + 29)

’32’

>>> str(‘py’)

‘py’

В этом примере видим, что независимо от того, что используется в качестве аргумента: конкретное число, целое число, сумма чисел или другая строка, эта функция превращает все эти данные в строчный тип. 

# Installation

Why bother with build systems or files? Use the CodePen Template to make your own Splitting demo!

Using NPM

Install Splitting from NPM:

Import Splitting from the package and call it. The CSS imports may vary depending on your bundler.

Using a CDN

TIP

CDN use is only recommended for demos / experiments on platforms like CodePen. For production use, bundle Splitting using the with Webpack or your preferred code bundler.

You can get the latest version of Splitting off of the unpkg CDN and include the necessary files as follows.

Then call Splitting on document load/ready or in a script at the bottom the of the .

Recommended Styles

Included in the package are two small stylesheets of recommended CSS that will make text and grid based effects much easier. These styles are non-essential, but provide a lot of value.

• includes many extra CSS Variables and psuedo elements that help power advanced animations, especially for text.
• contain the basic setup styles for cell/grid based effects you’d otherwise need to implement yourself.

Browser Support

Splitting should be thought of as a progressive enhancer. The basic functions work in any halfway decent browser (IE11+). Browsers that support CSS Variables ( ) will have the best experience. Browsers without CSS Variable support can still have a nice experience with at least some animation, but features like index-based staggering may not be feasible without JavaScript.

The styles in for the rely on , so there may be additional browser limitations. In general, so you should be in the clear.

Блокировки как менеджеры контекста

Блокировки реализуют API context manager и совместимы с оператором with. Использование оператора with позволяет обойтись без блокировки.

import threading
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def worker_with(lock):
    with lock:
        logging.debug('Lock acquired via with')
        
def worker_no_with(lock):
    lock.acquire()
    try:
        logging.debug('Lock acquired directly')
    finally:
        lock.release()

lock = threading.Lock()
w = threading.Thread(target=worker_with, args=(lock,))
nw = threading.Thread(target=worker_no_with, args=(lock,))

w.start()
nw.start()

Функции worker_with() и worker_no_with() управляют блокировкой эквивалентными способами.

$ python threading_lock_with.py

(Thread-1  ) Lock acquired via with
(Thread-2  ) Lock acquired directly

Методы перебирающие массив в ECMAScript 5

Подавляющее большинство браузеров поддерживают новые методы перебора массива, предоставляемые ECMAScript 5: forEach, map, и filter. Эти методы принимают функцию в качестве первого аргумента. Каждый элемент массива, в свою очередь, передается этой функции, которая принимает три аргумента: значение текущего элемента, его индекс и сам массив.

Функция, которую вы определяете, не должна использовать все три аргумента. В некоторых случаях вам понадобится использовать только значение элемента массива, что мы и покажем в наших примерах, демонстрирующих эти методы.

Метод forEach

Метод forEach перебирает элементы массива, как обычный JavaScript цикл for. Но вы не можете использовать оператор break для досрочного выхода, как в for. Метод forEach не возвращает значение.

В следующем примере мы объявляем массив и вызываем forEach. Передаем значение, индекс, и массив (v, i, a) в качестве аргумента функции, чтобы изменить массив, умножая каждое его значение на 2:

var ar = ;
ar.forEach( function(v, i, ar) { ar = v*2; } );
console.log( ar ); // 

В следующем примере мы создаем новый массив вместо того, чтобы преобразовать массив, вызванный forEach. Нам нужно только передать значение (v) для этого:

var ar = ;
var ar2 = []; // новый массив
// передаем значение, умножаем на 2, и выводим массив
ar.forEach( function(v) { ar2.push(v*2); } );
// вид нового массива
console.log( ar2 ); // 

Значение элемента массива может быть использовано в JavaScript цикле по массиву forEach для любых целей. Но если вы хотите создать новый массив на основе значений существующего, то метод map подходит больше.

Метод map

Метод map создает новый массив. Каждый элемент из существующего массива передается аргументу функции map.

Возвращаемое значение функции определяет значение соответствующего элемента нового массива. В данном примере мы возвращаем значение (v),умноженное на 2:

var ar = ;
var ar2 = ar.map( function(v) { return v*2; } );
console.log( ar2 ); // 

Вот еще один пример использования метода map для преобразования первой буквы значения каждого элемента в верхний регистр:

var ar = ;
var ar2 = ar.map( function(v) {
    return v.charAt(0).toUpperCase() + v.slice(1);
} );
console.log( ar2 ); // 

Часто нужно проверять тип значения элемента массива, прежде чем воздействовать на него. Например, если массив содержит значения, которые не являются строками в JavaScript, будет выводиться сообщение об ошибке «TypeError».

Поэтому мы включаем проверку типа:

var ar = ;
var ar2 = ar.map( function(v) {
    if ( typeof v === 'string' ) {
        return v.charAt(0).toUpperCase() + v.slice(1);
    }
} );
console.log( ar2 ); // 

Обратите внимание, что для значений, не являющихся строками, было возвращено undefined. Это происходит потому, что массив, возвращенный методом map, соответствует длине JavaScript созданного массива в цикле, для которого он вызывался

Это происходит даже в разреженных массивах.

Пересмотрим нашу функцию, чтобы вернуть исходное значение, когда тип не является строкой:

var ar = ;
var ar2 = ar.map( function(v) {
    if ( typeof v === 'string' ) {
        return v.charAt(0).toUpperCase() + v.slice(1);
    } else {
        return v;
    }
} );
console.log( ar2 ); // 

Что делать, если мы хотим, чтобы наш массив состоял только из элементов определенного типа? Для этого можем использовать метод filter.

Метод filter

Метод filter возвращает JavaScript созданный массив в цикле. Он выбирает из исходного массива и возвращает новый, состоящий из элементов, соответствующих заданным критериям. Мы можем использовать метод filter следующим образом, чтобы возвратить массив, содержащий только строковые значения:

var ar = ;
var ar2 = ar.filter( function(v) {
    if ( typeof v === 'string' ) {
        return true;
    }
} );
console.log( ar2 ); // 

Метод filter проверяет каждый элемент массива, и его аргумент функции должен возвратить true или false, чтобы указать, следует ли включать текущий элемент из JavaScript цикла по массиву в возвращаемый массив или нет.

В этом примере используется оператор остатка от деления (%), с помощью которого формируется новый массив, содержащий только четные значения из исходного массива:

var ar = ;
var ar2 = ar.filter( function(v) { return v % 2 === 0; } );
console.log( ar2 ); // 

Метод filter пропускает отсутствующие элементы в разреженных массивах. Таким образом, он может быть использован для создания обычного массива из разреженного:

var ar = ; // разреженный массив
// использование filter, чтобы вернуть плотную версию разреженного массива
var ar2 = ar.filter( function() { return true; } );
console.log( ar2 ); // 

Splitting a JavaScript string into multiple pieces.

In some cases, the separator character might exist in our string more than once.

//Example string with multiple hyphens.
var str = 'Cat-Dog-Fish';

//Split the string into an array
var splitString = str.split('-');

//Log our array to the console.
console.log(splitString);

Here, you can see that our string contains two hyphens. As a result, the split() method will split our string up into three strings:

The array that split() returned.

As you can see, there is no limit to the number of pieces that your string can be split into. If there were three hyphens in our string, that would result in four “pieces”.

Сравнение строк

Равенство

Как вы знаете, что сравнивая два строковых примитива, вы можете использовать операторы == или ===:

Если вы сравниваете строковый примитив с чем-то, что не является строкой, == и === ведут себя по-разному.

При использовании оператора == не-строка будет преобразована в строку. Это означает, что JavaScript попытается преобразовать его в строку перед сравнением значений.

Для строгого сравнения, когда не-строки не приводятся к строкам, используйте ===:

То же самое верно и для операторов неравенства !=  и !==:

Если вы не знаете, что использовать, отдавайте предпочтение строгому равенству ===.

Чувствительность к регистру

Когда требуется сравнение без учета регистра, обычно преобразуют обе строки в верхний или нижний регистры и сравнивают результат.

Однако иногда вам нужно больше контроля над сравнением. Об этом в следующем разделе …

Работа с диакритическими знаками в строках JavaScript

Диакритические знаки — это модификации буквы, например é или ž.

Возможно вы захотите указать, как они обрабатываются при сравнении двух строк.

Например, в некоторых языках принято исключать акценты при написании прописных букв.

Если вам нужно сравнение без учета регистра, простое преобразование двух строк в один и тот же регистр с помощью toUpperCase() или toLowerCase() не будет учитывать добавление / удаление акцентов и может не дать ожидаемого результата.

Если вам нужен более точный контроль над сравнением, используйте вместо него localeCompare:

Метод localeCompare позволяет указать «sensitivity» сравнения.

Здесь мы использовали base «sensitivity» для сравнения строк с использованием их «базовых» символов (что означает, что регистр и акценты игнорируются).

Поддержка localeCompare() браузерами:

Chrome: 24+

Edge: 12+

Firefox: 29+

Safari: 10+

Opera: 15+

Больше / меньше

При сравнении строк с использованием операторов < и > JavaScript будет сравнивать каждый символ в «лексикографическом порядке».

Это означает, что они сравниваются по буквам в том порядке, в котором они появляются в словаре:

True или false строки

Пустые строки в JavaScript считаются равными false при сравнении с использованием оператора == (но не при использовании ===)

Строки со значением являются «истинными», поэтому вы можете делать нечто подобное:

Нумерация потоков

Можно не сохранять дескрипторы всех потоков-демонов, чтобы убедиться в их завершении до выхода из основного процесса. enumerate() возвращает список активных экземпляров Thread. Список включает в себя текущий поток. Но присоединение к текущему потоку не разрешено (это приводит к ситуации взаимной блокировки), его необходимо пропустить.

import random
import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def worker():
    """thread worker function"""
    t = threading.currentThread()
    pause = random.randint(1,5)
    logging.debug('sleeping %s', pause)
    time.sleep(pause)
    logging.debug('ending')
    return

for i in range(3):
    t = threading.Thread(target=worker)
    t.setDaemon(True)
    t.start()

main_thread = threading.currentThread()
for t in threading.enumerate():
    if t is main_thread:
        continue
    logging.debug('joining %s', t.getName())
    t.join()

Поскольку worker спит в течение случайного отрезка времени, выходные данные программы могут отличаться. Это должно выглядеть примерно так:

$ python threading_enumerate.py

(Thread-1  ) sleeping 3
(Thread-2  ) sleeping 2
(Thread-3  ) sleeping 5
(MainThread) joining Thread-1
(Thread-2  ) ending
(Thread-1  ) ending
(MainThread) joining Thread-3
(Thread-3  ) ending
(MainThread) joining Thread-2

Работа с массивами JS — удаление из массива

Как мы знаем, массивы — это объекты, поэтому мы могли бы использовать delete, чтобы удалить значение:

var arr = 
delete arr
// теперь arr = 
alert(arr) // не задано

Вы видите, что значение удаляется, но не так, как мы хотели бы, потому что массив содержит незаданный элемент.

Оператор delete удаляет пару ключ-значение, и это все. Естественно, так как массив — это только хэш, позиция удаленного элемента становится undefined.

Чаще всего нам нужно удалить элемент, не оставляя «дыр» между индексами. Существует еще один метод, который поможет нам в этом.

Метод splice

Метод splice может удалять элементы и заменять их в JavaScript многомерных массивах. Его синтаксис:

arr.splice(index, deleteCount)

Удаляет элемент deleteCount, начиная с index, а затем вставляет на его место elem1, …, elemN.

Давайте рассмотрим несколько примеров:

var arr = 
arr.splice(1, 1)  // удалить 1 элемент, начиная с индекса 1
alert( arr.join(',') ) //  (1 элемент удален)

Таким образом, вы можете использовать splice, чтобы удалить один элемент из массива. Номера элементов массива сдвигаются, чтобы заполнить пробел:

var arr = 
arr.splice(0, 1)  // удаляем 1 элемент, начиная с индекса 0
alert( arr ) // "to" стал первым элементом

В следующем примере показано, как заменять элементы:

var arr = ;
// remove 3 first elements and add two
arr.splice(0, 3, "Come", "here") 
alert( arr ) // 

Метод splice возвращает массив удаленных элементов:

var arr = ;
// удаляем 2 первых элемента 
var removed = arr.splice(0, 2) 
alert( removed ) // "Go", "to" <-- массив удаленных элементов
splice может вставлять элементы, задайте 0 для deleteCount.
var arr = ;
// со второй позиции 
// удаляем 0 
// и вставляем "my", "sweet"
arr.splice(2, 0, "my", "sweet") 
alert( arr) // "Go", "to", "my", "sweet", "home"

Данный метод также может использовать отрицательный индекс, который отсчитывается с конца массива:

var arr = 
// для элемента -1 (предпоследнего)
// удаляем 0 элементов, 
// и вставляем 3 и 4
arr.splice(-1, 0, 3, 4)
alert(arr)  // 1,2,3,4,5

Задание для самостоятельного выполнения

Объект содержит свойство className, в котором содержатся имена классов, разделенные пробелами:

var obj = {
	className: 'open menu'
}

Напишите функцию removeClass(obj, cls), которая удаляет класс cls, если он задан:

removeClass(obj, 'open') // obj.className='menu'

removeClass(obj, 'blabla')  // без изменений (класса для удаления не существует)

Решение

Нужно разделить className на части и перебрать эти части через цикл. Если найдено совпадение, оно удаляется из JavaScript массива объектов, а затем добавляется обратно в конец.

Немного оптимизируем это:

function removeClass(elem, cls) {
  for(var c = elem.className.split(' '), i=c.length-1; i>=0; i--) {
    if (c == cls) c.splice(i,1)
  }
	
  elem.className = c.join(' ')
}
var obj = { className: 'open menu' }
removeClass(obj, 'open')
removeClass(obj, 'blabla')
alert(obj.className)   // menu

В приведенном выше примере переменная c задана в начале цикла, и для i задан ее последний индекс.

Сам цикл выполняется в обратном направлении, заканчиваясь условием i>=0. Это сделано потому, что i>=0 проверяется быстрее, чем i. Что ускоряет поиск свойства в c.

str.replace(str|regexp, str|func)

Это универсальный метод поиска-и-замены, один из самых полезных. Этакий швейцарский армейский нож для поиска и замены в строке.

Мы можем использовать его и без регулярных выражений, для поиска-и-замены подстроки:

Хотя есть подводный камень.

Когда первый аргумент является строкой, он заменяет только первое совпадение.

Вы можете видеть это в приведённом выше примере: только первый заменяется на .

Чтобы найти все дефисы, нам нужно использовать не строку , а регулярное выражение с обязательным флагом :

Второй аргумент – строка замены. Мы можем использовать специальные символы в нем:

Спецсимволы	Действие в строке замены
	вставляет
	вставляет всё найденное совпадение
	вставляет часть строки до совпадения
	вставляет часть строки после совпадения
	если это 1-2 значное число, то вставляет содержимое n-й скобки
	вставляет содержимое скобки с указанным именем

Например:

Для ситуаций, которые требуют «умных» замен, вторым аргументом может быть функция.

Она будет вызываться для каждого совпадения, и её результат будет вставлен в качестве замены.

Функция вызывается с аргументами :

1. – найденное совпадение,
2. – содержимое скобок (см. главу Скобочные группы).
3. – позиция, на которой найдено совпадение,
4. – исходная строка,
5. – объект с содержимым именованных скобок (см. главу Скобочные группы).

Если скобок в регулярном выражении нет, то будет только 3 аргумента: .

Например, переведём выбранные совпадения в верхний регистр:

Заменим каждое совпадение на его позицию в строке:

В примере ниже две скобки, поэтому функция замены вызывается с 5-ю аргументами: первый – всё совпадение, затем два аргумента содержимое скобок, затем (в примере не используются) индекс совпадения и исходная строка:

Если в регулярном выражении много скобочных групп, то бывает удобно использовать остаточные аргументы для обращения к ним:

Или, если мы используем именованные группы, то объект с ними всегда идёт последним, так что можно получить его так:

Использование функции даёт нам максимальные возможности по замене, потому что функция получает всю информацию о совпадении, имеет доступ к внешним переменным и может делать всё что угодно.

Извлечение части строки

Подстроки

Эти методы принимают индекс первого символа, который вы хотите извлечь из строки.

Они возвращают все от этого символа до конца строки:

Второй (необязательный) аргумент — это символ, на котором вы хотите остановиться.

Этот последний символ не включается в вывод:

Итак, какой из них вы должны использовать?

Они очень похожи, но с небольшими отличиями:

Если конечное значение выше начального, substring() «исправит» их, заменив их местами, но slice() просто вернет пустую строку.

substring() обрабатывает отрицательный индекс как 0. С slice () вы можете использовать отрицательное число для обратного отсчета от конца строки. Например, .slice(-3) вернет последние 3 символа строки.

Одиночные символы

Метод charAt() возвращает определенный символ из строки (помните, что индексы начинаются с 0):

Вы также можете рассматривать строку как массив и обращаться к ней напрямую следующим образом:

Split ( )

Методы Slice( ) и splice( ) используются для массивов. Метод split( )используется для строк. Он разделяет строку на подстроки и возвращает их в виде массива. У этого метода 2 параметра, и оба из них не обязательно указывать.

string.split(separator, limit);

• Separator: определяет, как строка будет поделена на подстроки: запятой, знаком и т.д.
• Limit: ограничивает количество подстрок заданным числом

Метод split( ) не работает напрямую с массивами. Тем не менее, сначала можно преобразовать элементы массива в строки и уже после применить метод split( ).

Давайте посмотрим, как это работает.

Сначала преобразуем массив в строку с помощью метода toString( ):

let myString = array.toString();

Затем разделим строку myString запятыми и ограничим количество подстрок до трех. Затем преобразуем строки в массив:

let newArray = myString.split(",", 3);

В виде массива вернулись первые 3 элемента 

Таким образом, элементы массива myString разделены запятыми. Мы поставили ограничение в 3 подстроки, поэтому в качестве массива вернулись первые 3 элемента.

Все символы разделены на подстроки