dollar

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

Либо придётся попотеть, постоянно совершенствуя свою регулярку и скрипты по мере поступления входящих данных. Например, пришёл адрес, где две запятые подряд (это опечатка) - ага, нужно учесть это в регулярке. Или, например, запятая пропущена, но всё же можно догадаться по какому-то критерию, что она там должна быть - ага, и это нужно учесть. И так далее.

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

let arr = str.split(",")
if (arr.length > 2) ....... // склеиваем все элементы, кроме последнего

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

У вас как минимум точка не экранирована, а значит это "любой символ". Но это так, к слову.

А ответ такой:

def URL = "sdfgsdfg https://inclouds.bizmail.ru hgfghfhgfhgf gfhgf"

print(URL.findAll(/(?<=:\/\/)[\w\d.]+/))

Хотя и он далёк от совершенства. Более точные условия задачи помогут его улучшить.

• слова, которые не завернуты в тег
  
• нет вложенных тегов
  

Следовательно, нужны слова, которые:

• либо сразу после </ ... >
  
• либо сразу после < ... />
  
• либо в начале строки
  

Так и запишем:
(?<=<\/[^<>]+>|<[^<>]+\/>|^)([^<>]+)
https://regex101.com/r/6OliJi/1

Каким образом можно сделать ровную табуляцию в строке?

Это можно сделать способом, который обычно называют "в лоб". То есть по сути просто взять и сделать, потому что здесь нет каких-либо сложностей даже для начинающего программиста. Проблема отсутствует, как таковая.

Не справиться может только ленивый, который желает переложить всю работу на плечи другого человека, либо несведущий в программировании человек. Судя по тому, что вы приводите код, вы всё же имеете какое-то отношение к программированию, пытаетесь сами что-то делать. Следовательно, это не второй, а первый вариант - лень.

Очень жаль.

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

Вот, например, у вас есть подзадача:

мне нужно как-то посчитать количество символов во всех строках

Отлично, ведь это отдельная подзадача, которую можно изолировать и просто решить, абстрагируясь от связей с другими подзадачами (ведь это ещё успеется):

text.split('\n').forEach(
  (s,i)=>console.log('Символов в строка №'+(i+1)+': '+s.length)
);

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

Предлагаю вам следующий алгоритм ваших дальнейших действий:

• Если вы поняли код выше и легко можете написать подобный, то, как я и ответил выше, просто решайте вашу задачу в лоб. Сложную задачу разбивайте на подзадачи. Обучение вас этому навыку выходит за рамки ответа на ваш вопрос, но вы можете начать с Википедии.
  
• Если вы с трудом поняли код выше или вообще ничего не поняли, но хотели бы понять, то подтяните знание самого языка. Без таких базовых понятий, как "массив" или "цикл", программировать практически не получится вообще. Объяснение основ выходит за рамки ответа на ваш вопрос, но вы можете начать с чтения учебника.
  
• Если вы не хотите ни в чём разбираться, а просто хотите, чтобы вам предложили готовое решение и чтобы оно просто работало, то подтяните ваше умение формулировать, чего именно вы хотите. Текущий ваш вопрос сформулирован сумбурно, в стиле "чтобы у меня всё было, и мне за это ничего не было". При таком подходе придётся слишком долго ждать телепата 80 лвл. Лучше будет красиво, коротко и ясно объяснить детали, чтобы помочь смог любой специалист без уточняющих вопросов. Увы, объяснение принципов того, как задавать вопросы, снова выходит за рамки ответа на ваш изначальный вопрос, но вы можете начать с чтения правил этого ресурса. Хотя лаконично формулировать мысли они вас не научат. Но ведь надо же с чего-то начинать, верно?
  

(;")([^"]*)([oea])([^oea;"]*")$

Первая группа - точка с запятой и кавычка.

Вторая группа - любое (даже ноль) количество символов, кроме самой кавычки. Очевидно, в этой группе могут быть (а могут и не быть) "o", "e" или "a", но они не будут последние. Если в эту группу включить последнюю "o", "e" или "a", то сформировать следующую группу не получится, поэтому регулярка так делать не будет.

Третья группа символов чёткая - это один символ: "o", "e" или "a".

Четвёртая группа символов - любое (даже ноль) количество символов, кроме "o", "e", "a", ";" и самой кавычки, за которым следует кавчка. Этой группой мы обозначаем, что предыдущая "o", "e" или"a" была именно последней и больше не должна встречаться.

$ в конце означает конец строки. То есть все найденные группы должны идти именно в таком порядке и прилегать вплотную к концу строки. Во всех группах, кроме первой, исключена кавычка, что делает невозможных захват других сегметов строки.

Очевидно, что заменить нужно на комбинацию из найденных групп. А именно, вторая группа лишняя. Точно не знаю, как это будет в Sublime. Что-то из этого должно сработать:

• $1$3$4
  
• \1\3\4
  

Вариант 1. Отрезание хвоста:
^(.*);.*$
Заменить на: $1


Вариант 2. Замена только строк ровно с трёмя сегментами:
^([^;]*;[^;]*);[^;]*$
Заменить на: $1

\[(\d+)\].+сек.+?(\d?\.?\d+) к?м

.+ - жадный поиск, хватает всё, что может. А чтобы выражение подошло, допустимо захватить всё, кроме последней цифры.
Так что самое простое решение - сделать этот захват ленивым.

UPD: под Lua:

string.match(str, "%[([0-9]+)%].+сек.-([0-9]?%.?[0-9]+) к?м")

Без lookahead нужно использовать обычную группировку (скобки).

Пример для схемы без пробелов:
magnet:\?.*?xt=urn:([a-z]+:[a-f0-9]+)

Пример для btih с пробелами:

magnet:\?.*?xt=urn:btih:([a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9](?:\s*)[a-f0-9])

Короткий ответ:
/(?<=<img [^<>]*?)src(?:set)?="([^"]*)"/g

Но чем больше дополнительных условий и хотелок, тем больше доп. кода понадобится или более монструозным получится рег. выражение. Универсальный способ вряд ли получится. Всегда найдётся способ сломать регулярку.

Главное, чтобы было четыре секции между двоеточиями.

Если это главное (и единственное) требование, то сами секции задаются как раз этим двоеточием. Поэтому банальное (но пока что ошибочное) рег. выражение:
.*:.*:.*:.*
Двоеточие в этом выражении соответствует двоеточию в исходной строке. Поэтому строка a:b:c будет не валидной - слишком мало секций. Выражение .* означает любое количество любых символов. Ошибка здесь в том, что любым символом также может быть двоеточие, поэтому это регулярное выражение разрешает более, чем 4 секции. Чтобы исправить это, нужно запретить символ двоеточия в последовательности любых символов. Выражение [^:] означает любой символ, кроме двоеточия:
[^:]*:[^:]*:[^:]*:[^:]*

Остался последний штрих. Пока что это рег. выражение всё ещё разрешает более одной секции, потому что поиск можно начинать с середины строки и заканчивать, не доходя до конца. Поэтому если подсунуть строку a:b:c:d:e:f выражение убедится, что подстрока a:b:c:d соответствует рег. выражению, а значит валидна. Чтобы исправить это, нужно указать, что проверку нужно начинать с самого начала строки и дойти до самого конца строки. То есть рассматривать строку целиком, а не по частям. Это делается с помощью указателей позиций. Символ ^ (в начале) означает начало строки, а символ $ (в конце) означает конец строки:
^[^:]*:[^:]*:[^:]*:[^:]*$

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

Однако данное выражение можно немного улучшить, в зависимости от дополнительных требований. Например, нас может не устроить, что для каждой секции считается валидным любое количество символов, даже нулевое. То есть строка a:b::c тоже будет валидной. Для этого нужно сменить квантификатор * на какой-либо другой. Например, можно сменить на +, который означает любое количество вхождений (символа) больше нуля, то есть 1 и более:
^[^:]+:[^:]+:[^:]+:[^:]+$

Далее, может быть желательно выделить группы, чтобы рег. выражение не только проверяло исходную строку на соответствие шаблону ip:port:user:pass, но и извлекало эти самые переменные. Группы задаются просто скобками. Очевидно, что разделители и указатели позиций в группы не входят:
^([^:]+):([^:]+):([^:]+):([^:]+)$

Далее можно вспомнить, что параметр port может содержать лишь арабские цифры. В регулярных выражениях \d (или [0-9]) означает любую цифру. Так что легко вносим улучшение:
^([^:]+):(\d+):([^:]+):([^:]+)$
Хотя постойте-ка. Это ещё не всё с параметром port. Ведь абсолютное любое число, состоящее из цифр, нас не устроит. Как минимум, порт не может быть больше 65535, поэтому любое число выше считается ошибкой. В принципе, на данном этапе можно не заморачиваться и просто проигнорировать это требование, а реально проверить его позже кодом типа такого: $post < 65356, но в качестве примера можно всё же ограничить количество цифр от 2 до 5:
^([^:]+):(\d{2,5}):([^:]+):([^:]+)$
Квантификатор {2,5} означает, что количество вхождений (цифр) должно быть не менее 2 и не более 5, иначе секция будет считаться не валидной, а значит и вся строка тоже.

Далее, можем также сделать более строгое условие для параметра ip. Для простоты будем считать, что разрешён только IPv4, а IPv6 нельзя использовать. Тогда условием будет 4 цифры, разделённые точкой. Каждая цифра от 1 до 3 символов:
\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}
Ой, ошибочка вышла! Дело в том, что символ . является квантификатором. И чтобы рег. выражению сказать, что нам нужен сам символ точки, нужно его экранировать: \.
В результате полностью рег. выражение получается таким:

^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):(\d{2,5}):([^:]+):([^:]+)$

Да, получился монстр. Но нет предела совершенству.

Правда, на этом этапе улучшать проверки уже не целесообразно. Далее уже кодом PHP можно проверить более строги условия. Например, сейчас в качестве ip будет валидной строка 300.400.500.600. Ведь всё сходится - 4 числа, разделённые точкой, в каждом от 1 до 3 цифр. Поэтому нужно либо более монструозное выражение лепить, либо кодом проверять, либо отдать на откуп сетевым ошибкам подключения - зависит от конкретного приложения и конкретной задачи.

Рег. выражения не заточены на сравнение чисел, например. Чтобы проверить, что число находится в диапазоне от 0 до 255, придётся лепить что-то такое:
(?:\d\d?|[0-1]\d\d|2[0-4]\d|25[0-5])
То есть это вообще поразрядная проверка. Глупо. Проще это делать кодом, если это действительно нужно.

На данном же этапе имеет смысл проверять лишь то, подо что заточены регулярные выражения. Например, можно ограничить класс символов, которые входят в user и в pass. Например, в пароле можно разрешить только латинские символы и цифры, а также ограничит длину: пароль не может быть меньше 6 и не может быть больше 32 символов:
[a-z0-9]{6,32}
(просто пример)

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

$noUp[$i]

Проверить так:
/[g-z]|[a-f]{3,}/i