| Беларусь, рогачёв |
Инспектор
Вы можете этот курс.
Опубликован: 23.12.2005 | Уровень: специалист | Доступ: платный | ВУЗ: Московский физико-технический институт
Лекция 4:
Контейнеры
Что умеют строки во Флэш
Сейчас мы кратко опишем функциональность каждого из методов класса String во Флэш. Все эти методы работают как с объектными, так и с примитивными строками. Это, кстати, сразу означает, что ни один из методов не меняет исходную строку (поскольку невозможно изменить примитивный объект). Так что можно писать, например, так: trace("my name".toUpperCase()), и это действительно выведет на печать MY NAME, хотя подобный код и нельзя назвать хорошо читаемым.
Итак, методы charAt и charCodeAt позволяют получить символ и его код по заданному индексу; метод concat присоединяет к нашей строке строки, переданные в аргументах, и возвращает результат; методы indexOf и lastIndexOf позволяют находить подстроку в строке, ведя поиск в прямом и в обратном направлении соответственно (начиная с заданного индекса); методы slice, substr и substring позволяют разными способами выделять подстроку ; методы toUpperCase и toLowerCase переводят все буквы в заглавный или строчный регистр; наконец, метод split разбивает строку на лексемы (по заданному разделителю). Особняком стоит метод String.fromCharCode. Он является чем-то вроде статического метода класса String и не нуждается в объекте строкового типа для своего вызова. Чтобы вызвать этот метод, нужно так и написать: String.fromCharCode, а в качестве аргументов передать один или несколько кодов символов, из которых и будет сформирована строка.
Конечно, этого краткого описания недостаточно для уверенной работы со строками Флэш, так что сейчас мы приведем примеры применения всех этих методов, кроме split. Метод split настолько хорош и полезен, что пример его применения мы выделим отдельно и опишем в следующем подпараграфе. Все же прочие примеры представлены в следующем коде:
a_str = "Очень длинная строка";
trace(
"a_str.toLowerCase() = " +
a_str.toLowerCase()
); // Переводим строку в нижний регистр
trace(
"a_str.toUpperCase() = " +
a_str.toUpperCase()
); // Переводим строку в верхний регистр
trace("");
trace(
"a_str.charAt(3) = " +
a_str.charAt(3)
); // Буква "н"
trace(
"a_str.charCodeAt(5) = " +
a_str.charCodeAt(5)
); // Код пробела
trace("");
trace(
"a_str.concat(', да-да. ', a_str) = \n\t" +
a_str.concat(', да-да. ', a_str)
);
trace("");
trace(
"String.fromCharCode(46, 56, 74, 34, 45) = " +
String.fromCharCode(46, 56, 74, 34, 45)
);
trace("");
trace(
"a_str.indexOf('н') = " +
a_str.indexOf('н')
); // Первая буква "н"
trace(
"a_str.indexOf('нн') = " +
a_str.indexOf('нн')
); // Первое (оно же и последнее) сочетание букв "нн"
trace(
"a_str.lastIndexOf('н') = " +
a_str.lastIndexOf('н')
); // Последняя буква "н"
trace(
"a_str.lastIndexOf('нн') = " +
a_str.lastIndexOf('нн')
); // Последнее (оно же первое) сочетание букв "нн"
trace(
"a_str.indexOf('н', 6) = " +
a_str.indexOf('н', 6)
); // Первая буква "н" после 6-й позиции (или на 6-й).
trace(
"a_str.lastIndexOf('н', 6) = " +
a_str.lastIndexOf('н', 6)
); // Последняя буква "н" перед 6-й позицией (или на 6-й).
trace("-------------");
/* Несколько примеров на метод slice */
/* Он работает так же, как аналогичный метод в массиве */
trace(
"a_str.slice(8, 12) = " +
a_str.slice(8, 12)
); // Кусок строки в районе букв "нн"
trace(
"a_str.slice(8, 3) = " +
a_str.slice(8, 3)
); // Если второй аргумент меньше первого, но положителен,
// возвращается пустая строка.
trace(
"a_str.slice(8, -3) = " +
a_str.slice(8, -3)
); // Если второй аргумент отрицателен,
// отсчитываем от конца строки назад.
trace("-------------");
/* Посмотрим, чем от slice отличается substring */
trace(
"a_str.substring(8, 12) = " +
a_str.substring(8, 12)
); // Тот же результат, что и для slice
trace(
"a_str.substring(8, 3) = " +
a_str.substring(8, 3)
); // Если второй аргумент меньше первого,
// аргументы меняются местами
trace(
"a_str.substring(8, -3) = " +
a_str.substring(8, -3)
); // Если любой из аргументов отрицателен,
// он заменяется нулем. Затем, если нужно,
// аргументы меняются местами
trace("-------------");
/* Еще один метод выделения подстроки: substr */
trace(
"a_str.substr(8, 3) = " +
a_str.substr(8, 3)
); // Здесь второй аргумент задает длину подстроки.
trace(
"a_str.substr(8) = " +
a_str.substr(8)
); // Если же второй аргумент вовсе не передавать,
// то подстрока берется до конца строки
// substring и slice в этом случае работают точно так же.Этот длинный код выводит следующий длинный текст:
a_str.toLowerCase() = очень длинная строка
a_str.toUpperCase() = ОЧЕНЬ ДЛИННАЯ СТРОКА
a_str.charAt(3) = н
a_str.charCodeAt(5) = 32
a_str.concat(', да-да. ', a_str) =
Очень длинная строка, да-да. Очень длинная строка
String.fromCharCode(46, 56, 74, 34, 45) = .8J"-
a_str.indexOf('н') = 3
a_str.indexOf('нн') = 9
a_str.lastIndexOf('н') = 10
a_str.lastIndexOf('нн') = 9
a_str.indexOf('н', 6) = 9
a_str.lastIndexOf('н', 6) = 3
-------------
a_str.slice(8, 12) = инна
a_str.slice(8, 3) =
a_str.slice(8, -3) = инная стр
-------------
a_str.substring(8, 12) = инна
a_str.substring(8, 3) = нь дл
a_str.substring(8, -3) = Очень дл
-------------
a_str.substr(8, 3) = инн
a_str.substr(8) = инная строкаОбратите внимание на разницу в работе slice, substring и substr. Примеры демонстрируют эту разницу для всех случаев, которые могут быть важны на практике. Интересно также, что существует (объявленная устаревшей) глобальная функция substring, которой в качестве первого аргумента передается строка, а второй и третий аргумент - числа. При этом работает она точно так же, как метод substr класса String (а вовсе не как метод substring, как могло бы показаться из-за совпадения названий)!
Нерассмотренным у нас пока остался простой, но существенный вопрос: а как узнать длину строки? Как и в случае массива, специального метода для этого не предусмотрено, зато можно обратиться к свойству по имени length.
Пример работы со строками и массивами
Согласитесь, что сделать простую замену подстроки при помощи стандартных методов строки и массива - это то, что программисты называют " good thing " (хорошее дело). В первую очередь для этого нам понадобится метод split, для данной строки возвращающий массив лексем, которые были разделены в строке переданным в аргументах метода разделителем. Давайте в качестве разделителя возьмем удаляемую подстроку. Затем мы можем снова соединить этот массив в строку методом join, а в качестве "склеивающей" строки передать ту строчку, на которую мы хотим заменить удаляемую. Вот и все! Смотрите, как это работает:
text_str = "Мы любим буги-вуги, мы танцуем только буги";
new_str = text_str.split("уги").join("аги");
trace("text_str = " + text_str);
trace("new_str = " + new_str);В результате действительно получаем:
text_str = Мы любим буги-вуги, мы танцуем только буги new_str = Мы любим баги-ваги, мы танцуем только баги
