Является ли Javascript чувствительным к регистру? — Особенности Javascript с учетом регистра
JavaScript — это интерпретируемый язык сценариев. Он используется в веб-разработке для создания интерактивных веб-страниц, получая доступ к машинным ресурсам клиентов для разработки сценариев на стороне клиента, написанных на JavaScript. Так как он должен быть скомпилирован, его правило опирается на платформу, на которой делается эта интерпретация. Стандарты javascript хотели бы, чтобы он был чувствительным к регистру. Хотя Javascript чувствителен к регистру, некоторые платформы не учитывают его регистрозависимый характер.
Что такое JavaScript?
Javascript — это динамический язык веб-сценариев. Обычно он используется в качестве языка веб-контента, реализации которого позволяют клиентскому сценарию взаимодействовать с пользователем и создавать динамические страницы. Это интерпретируемый искусственный язык с объектно-ориентированными возможностями.
Сначала JavaScript был назван LiveScript, однако браузер изменил свое имя на JavaScript, предположительно, из-за радости, создаваемой Java. JavaScript создал свое введение с именем LiveScript. Общее ядро языка было встроено в браузер.
Особенности JavaScript: —
- JavaScript — это легкий, искусственный и интерпретируемый язык.
- Используется для создания сетевых приложений.
- Интегрирован с Java.
- Интегрирован с языком разметки гипертекста.
- Открытая и кроссплатформенная
Что такое чувствительность к регистру?
Текст, чувствительный к заглавным буквам. Например, «Компьютер» и «компьютер» — это два совершенно разных слова, в результате «С» в верхнем регистре в первом примере и в нижнем регистре во втором примере. В модных системах пароли чувствительны к регистру, а имена пользователей иногда чувствительны к регистру.
Все, что не учитывает регистр, часто вводится в верхнем или нижнем регистре. Например, строка программы Windows или MS-DOS не чувствительна к регистру, однако строка программы Linux чувствительна к регистру.
Почему чувствительность к регистру намного важнее в JavaScript?
Это природа зверя. Для начала сценарий написан в виде простого текста, однако это не просто разметка, подобная языку разметки гипертекста (которая в основном нечувствительна к регистру), это код, и он подвергается более тщательному анализу внутренней работой браузера (API DOM).
var names, Names;
Две переменные выглядят почти одинаково, но для Javascript они совершенно разные. Важно то, что мы склонны признавать это не по важности, а по ужасной природе. Это то, что это.
function Person(name, age)
var person = new Person(«Zach», 29);
Однако мы можем игнорировать структуру этого кода, поскольку объекты могут не иметь покрытия. Цель здесь — указать, что человек и Человек — это 2 совершенно разных объекта. Человек является оператором строителя объектов, а человек является экземпляром этой категории строителей.
В нынешнем виде мы склонны ко всем проверять нашу капитализацию или сталкиваться с возможными негативными последствиями, такими как синтаксические ошибки, ссылочные ошибки и различные исключения. Осторожно следите и помните, что Javascript чувствителен к регистру.
Почему JavaScript чувствителен к регистру, а HTML — нет?
Скрипт представляет собой простой текст, а не просто разметку, как язык разметки гипертекста, то есть регистр не учитывается. В JavaScript ключевое слово while должно быть «while», а не «while» или «WHILE». Чувствительность к регистру очень важна, поскольку она тесно связана с языком разметки гипертекста, однако некоторые способы и события упоминаются иначе. JavaScript имеет строгий синтаксис для метода клиентских скриптов, написанных на JavaScript.
Некоторые теги и атрибуты в языке разметки гипертекста имеют эквивалентное имя как объекты и свойства JavaScript. В HTML имена атрибутов и тегов не чувствительны к регистру. Закрытая ассоциация языка разметки гипертекста и JavaScript вызовет путаницу, поэтому чувствительность к регистру является дополнительной жизненно важной для JavaScript.
Следующие два слова в JavaScript совершенно разные:
var demo;
var DEMO;
Следующее — другой объект из-за чувствительных к регистру особенностей Javascript:
function Employee(id, name, subject)(
this.id = id;
this.name = name;
)
var employee = new Employee(«ee1», “John”, ”30”);
При работе с JavaScript проверяйте заглавную букву переменной, оператора и имени объекта. Это может остановить синтаксис и различные ошибки.
Является ли Javascript чувствительным к регистру?
JavaScript является регистрозависимым языком. Это подразумевает, что ключевые слова языка, переменные, имена операций и другие идентификаторы должны быть напечатаны с использованием одинаковых заглавных букв.
Таким образом, идентификаторы Time и TIME могут передавать совершенно разные значения в JavaScript.
ПРИМЕЧАНИЕ. Следует проявлять осторожность при написании имен переменных и производительности в JavaScript.
В следующем примере показано, что JavaScript является регистрозависимым языком:
My favorite subject
var subject, Subject;
subject = «Java»;
Subject = «Maths»;
document.getElementById(«demo»).innerHTML = subject;
My favorite subject
var subject, Subject;
subject = «Java»;
Subject = «Maths»;
document.getElementById(«demo»).innerHTML = subject;
My favorite subject
var subject, Subject;
subject = «Java»;
Subject = «Maths»;
document.getElementById(«demo»).innerHTML = subject;
Предположим, мы хотим найти иглу строковой переменной в стоге сена строковой переменной. Есть три ошибки:
- Интернационализированные приложения должны избегать string.toUpperCase и string.toLowerCase. Вместо этого используйте ежедневное выражение, которое игнорирует регистр. Например, volt-ampere needleRegExp = new RegExp (игла, «i»); сопровождаемый needleRegExp.test (стог сена).
- В общем, вы, возможно, не поняли бы ценность иглы. Позаботьтесь, чтобы игла не содержала специальных символов регулярного выражения. Избегайте этой иглы эксплуатации. Замените (/(-(\)()*+. \\^$ | # \ s) / g, «\\ $ &») ;.
- В других случаях, если вы хотите точно подобрать иглу и хейрик, просто игнорируя регистр, убедитесь, что в начале у вас есть «^», а на кончике построителя регулярных выражений — «$».
Принимая во внимание пункты (1) и (2), примером может быть:
var haystack = «A. BAIL. Of. Hay.»;
var needle = «bail.»;
var needleRegExp = new RegExp(needle.replace(/(-(\)()()*+. \\^$|#\s)/g, «\\$&»), «i»);
var result = needleRegExp.test(haystack);
if (result) (
// Your code here
)
Заключение. Является ли Javascript чувствительным к регистру?
Таким образом, учитывая вышеперечисленные моменты, мы можем сказать, что JavaScript является чувствительным к регистру языком сценариев. Что означает, что язык рассматривает заглавные буквы как совершенно отличные от их маленьких аналогов. Например, если вы объявляете в JavaScript переменную, называемую totalCost, вы должны использовать totalCost, чтобы увидеть эту переменную, а не TotalCost, Total cost или другую комбинацию.
В JavaScript чувствительность к регистру не просто применяется к именам переменных, но дополнительно к ключевым словам JavaScript, обработчикам событий и свойствам объектов или способам. Ключевые слова в JavaScript все мало, например, в то время как, если, еще, и так далее. С другой стороны, способы (свойства) используют соглашение об именовании «верблюд» (первое слово состоит из маленькой буквы, а каждая упорядоченная 1-я буква каждого слова пишется с большой буквы), например, toArray (), lastModified () и т. Д.,
Рекомендуемые статьи
Это руководство к регистру Javascript. Здесь мы обсудили значение javascript с его функциями, CaseSensitivity, то, как Javascript чувствителен к регистру, и т. Д. Вы также можете посмотреть следующую статью, чтобы узнать больше —
- Шпаргалка JavaScript
- Является ли MongoDB с открытым исходным кодом
- SQL Microsoft?
- Бесплатно
- Инструменты для JavaScript
- Функции регулярных выражений в Python (пример)
String.prototype.includes()
Метод includes() проверяет, содержит ли строка заданную подстроку, и возвращает, соответственно true или false .
Синтаксис
str.includes(searchString[, position])
Параметры
Строка для поиска в данной строке.
Позиция в строке, с которой начинать поиск строки searchString , по умолчанию 0.
Возвращаемое значение
true , если искомая строка была найдена в данной строке; иначе false .
Описание
Этот метод позволяет вам определять, содержит ли строка другую строку.
Чувствительность к регистру символов
Метод includes() является регистрозависимым. Например, следующее выражение вернёт false :
"Синий кит".includes("синий"); // вернёт false
Примеры
Использование includes()
var str = "Быть или не быть вот в чём вопрос."; console.log(str.includes("Быть")); // true console.log(str.includes("вопрос")); // true console.log(str.includes("несуществующий")); // false console.log(str.includes("Быть", 1)); // false console.log(str.includes("БЫТЬ")); // false
Полифил
Этот метод был добавлен в спецификации ECMAScript 2015 и может быть недоступен в некоторых реализациях JavaScript. Однако, можно легко эмулировать этот метод:
if (!String.prototype.includes) String.prototype.includes = function (search, start) "use strict"; if (typeof start !== "number") start = 0; > if (start + search.length > this.length) return false; > else return this.indexOf(search, start) !== -1; > >; >
Спецификации
| Specification |
|---|
| ECMAScript Language Specification # sec-string.prototype.includes |
Совместимость с браузерами
BCD tables only load in the browser
String.prototype.contains
В Firefox с версии 18 по версию 39, этот метод назывался «contains». Он был переименован в «includes» в замечании Firefox bug 1102219 по следующей причине:
Как было сообщено, некоторые сайты, использующие MooTools 1.2, ломаются в Firefox 17. Эта версия MooTools проверяет существование метода String.prototype.contains() и, если он не существует, добавляет свой собственный. С введением этого метода в Firefox 17, поведение этой проверки изменилось таким образом, что реализация String.prototype.contains() , основанная на MooTools, сломалась. В результате это изменение было отключено в Firefox 17. Метод String.prototype.contains() доступен в следующей версии Firefox — Firefox 18.
MooTools 1.3 принудительно использует свою собственную версию метода String.prototype.contains() , так что использующие его веб-сайты не должны ломаться. Тем не менее, следует отметить, что сигнатура метода в MooTools 1.3 отличается от сигнатуры метода в ECMAScript 2015 (во втором аргументе). В MooTools 1.5+ сигнатура изменена для соответствия стандарту ES2015.
В Firefox 48, метод String.prototype.contains() был удалён. Следует использовать только String.prototype.includes() .
Смотрите также
- Array.prototype.includes() Экспериментальная возможность
- TypedArray.prototype.includes() (en-US) Экспериментальная возможность
- String.prototype.indexOf()
- String.prototype.lastIndexOf()
- String.prototype.startsWith()
- String.prototype.endsWith()
Основы объектов в JavaScript
В этой статье мы рассмотрим объекты в JavaScript. Мы будем разбирать основы синтаксиса объектов JavaScript и заново изучим некоторые возможности JavaScript, которые мы уже исследовали ранее на курсе, подтвердив тот факт, что большая часть функциональности, с которой мы уже столкнулись, в действительности является объектами.
| Необходимые знания: | Элементарная компьютерная грамотность, базовое понимание HTML и CSS, знакомство с основами JavaScript (см. Первые шаги и Структурные элементы). |
|---|---|
| Цель: | Понимать основу теории перед началом объектно-ориентированного программирования, как это связано с JavaScript («большинство сущностей являются объектами»), и как начать работу с объектами JavaScript. |
Основы объектов
Объект — это совокупность связанных данных и/или функциональных возможностей. Обычно состоят из нескольких переменных и функций, которые называются свойства и методы, если они находятся внутри объектов. Разберём пример, чтобы показать, как они выглядят.
Как и во многих случаях в JavaScript, создание объекта часто начинается с определения и инициализации переменной. Попробуйте ввести следующий код JavaScript в ваш файл, а затем сохраните файл и обновите страницу браузера:
const person = >;
Если вы введёте person в текстовое JS консоль и нажмёте клавишу Enter, должен получиться следующий результат:
Поздравляем, вы только что создали ваш первый объект. Но это пустой объект, поэтому мы не можем с ним ничего сделать. Давайте обновим наш объект, чтобы он выглядел так:
const person = name: ["Bob", "Smith"], age: 32, gender: "male", interests: ["music", "skiing"], bio: function () alert( this.name[0] + " " + this.name[1] + " is " + this.age + " years old. He likes " + this.interests[0] + " and " + this.interests[1] + ".", ); >, greeting: function () alert("Hi! I'm " + this.name[0] + "."); >, >;
После сохранения и обновления, попробуйте ввести что-нибудь следующее в консоль JavaScript браузера:
.name; person.name[0]; person.age; person.interests[1]; person.bio(); person.greeting();
Как видите, наш объект содержит некоторые данные, а также несколько методов. У нас же с помощью простого синтаксиса есть доступ к ним.
Примечание: Если у вас возникли проблемы с применением файла в работе, попробуйте сравнить ваш код с нашей версией — см. oojs-finished.html (также see it running live). Одна из распространённых ошибок, когда вы начинаете с объектами ставить запятую в конце последнего члена — это приводит к ошибке.
Итак что здесь происходит? Объект состоит из нескольких элементов, каждый из которых имеет своё название (пример name и age выше), и значение (пример [‘Bob’, ‘Smith’] и 32 ). Каждая пара название/значение должны быть разделены запятой, а название и значение в каждом случае разделяются двоеточием. Синтаксис всегда следует этому образцу:
const objectName = member1Name: member1Value, member2Name: member2Value, member3Name: member3Value, >;
Значение члена объекта может быть чем угодно — в нашем объекте person есть строка, число, два массива, и две функции. Первые четыре элемента это элементы данных, относящиеся к свойствам объекта. Последние два элемента являются функциями, которые позволяют объекту что-то сделать с элементами данных, и называются методами объекта.
Такие объекты называются литералами объекта (object literal) — мы буквально вписали все содержимое объекта для его создания. Этот способ сильно отличается от объектов реализованных классами, которые мы рассмотрим позже.
Очень часто для создания объекта используется литерал объекта когда вам нужно каким-то образом перенести ряд структурированных, связанных элементов данных, например, отправляя запрос на сервер, для размещения их в базе данных. Отправка одного объекта намного эффективнее, чем отправка нескольких элементов по отдельности, и с ним легче работать чем с массивом, если требуется идентифицировать отдельные элементы по имени.
Точечная запись (Dot notation)
Выше вы получили доступ к свойствам и методам используя точечную запись (dot notation). Имя объекта (person) действует как пространство имён (namespace) — оно должно быть введено первым, для того чтобы получить доступ ко всему что заключено (encapsulated) внутри объекта. Далее вы пишете точку, затем элемент, к которому хотите получить доступ — это может быть имя простого свойства, элемент массива, или вызов одного из методов объекта, например:
.age; person.interests[1]; person.bio();
Внутренние пространства имён (Sub-namespaces)
Можно даже сделать значением элемента объекта другой объект. Например, попробуйте изменить значение свойства name с такого
name: ['Bob', 'Smith'],
name : first: 'Bob', last: 'Smith' >,
Здесь мы фактически создаём внутреннее пространство имён (sub-namespace). Это звучит сложно, но на самом деле это не так — для доступа к этим элементам вам нужно сделать один дополнительный шаг с ещё одной точкой. Попробуйте в консоли браузера следующее:
.name.first; person.name.last;
Важно: На этом этапе вам также нужно будет пересмотреть код метода и изменить все экземпляры с
[0]; name[1];
.first; name.last;
Иначе ваши методы больше не будут работать.
Скобочная запись (Bracket notation)
Существует другой способ получить свойства объекта — использовать скобочную запись (bracket notation). Вместо написания этого кода:
.age; person.name.first;
Вы можете использовать следующий
["age"]; person["name"]["first"];
Это выглядит очень похоже на то, как вы получаете элементы массива, и в принципе это так и есть — вместо использования числовых индексов для выбора элемента, вы ассоциируете имя свойства для каждого значения. Ничего удивительного, что эти объекты иногда называют ассоциативными массивами — они сопоставляют строки со значениями так же, как массивы сопоставляют числовые индексы со значениями.
Запись элементов в объект
До сих пор мы рассматривали только возврат (или получение) элементов объекта — вы так же можете установить (обновить) значение элемента объекта просто объявив элемент, который вы хотите установить (используя точечную или скобочную запись), например:
.age = 45; person["name"]["last"] = "Cratchit";
Попробуйте ввести эти строки, а затем снова верните элементы, чтобы увидеть, как они изменились
.age; person["name"]["last"];
Вы можете не просто обновлять и устанавливать значения свойств и методов объекта, а так же устанавливать совершенно новые элементы. Попробуйте их в консоли JS:
["eyes"] = "hazel"; person.farewell = function () alert("Bye everybody!"); >;
Теперь вы можете проверить ваши новые элементы:
["eyes"]; person.farewell();
Одним из полезных аспектов скобочной записи является то, что с её помощью можно динамически задавать не только значения элементов, но и их имена. Предположим, что мы хотим, чтобы пользователи могли хранить пользовательские типы данных, введя имя и значение элемента в два следующих поля? Мы могли бы получить эти значения следующим образом:
let myDataName = nameInput.value; let myDataValue = nameValue.value;
Затем мы можем добавить имя и значение этого нового элемента в объект person таким образом:
[myDataName] = myDataValue;
Чтобы проверить это, попробуйте добавить следующие строки в свой код, после закрывающей скобки объекта person :
let myDataName = "height"; let myDataValue = "1.75m"; person[myDataName] = myDataValue;
Теперь попробуйте сохранить и обновить, затем введите следующее в консоль браузера:
.height;
Добавление свойства объекта с использованием вышеописанного метода невозможно с использованием точечной записи, которая может принимать только литеральное имя элемента, а не значение переменной указывающее на имя.
Что такое «this»?
Возможно, вы заметили что-то странное в наших методах. Посмотрите на этот пример:
greeting: function() alert('Hi! I\'m ' + this.name.first + '.'); >
Вы, вероятно, задаётесь вопросом, что такое «this»? Ключевое слово this , ссылается на текущий объект, внутри которого пишется код — поэтому в нашем случае this равен объекту person . Но почему просто не написать person ? Как вы увидите в статье Object-oriented JavaScript for beginners (en-US) (Объектно-ориентированный JavaScript для начинающих), когда мы начинаем создавать конструкторы и т.д., this очень полезен — он всегда будет гарантировать, что используется верное значение, когда контекст элемента изменяется (например, два разных экземпляра объекта person могут иметь разные имена, но захотят использовать своё собственное имя при приветствии.
Давайте проиллюстрируем, что мы имеем в виду, с упрощённой парой объектов person :
const person1 = name: "Chris", greeting: function () alert("Hi! I'm " + this.name + "."); >, >; const person2 = name: "Brian", greeting: function () alert("Hi! I'm " + this.name + "."); >, >;
В этом случае, person1.greeting() выведет «Hi! I’m Chris.». person2.greeting() , с другой стороны, выведет «Hi! I’m Brian.», хотя код метода одинаковый в обоих случаях. Как мы сказали ранее, this равен объекту, внутри которого находится код — это не очень полезно, когда вы пишите литералы объектов вручную, но оно действительно помогает, когда вы генерируете объекты динамически (например используя конструкторы). Это станет понятнее чуть позже.
Все это время вы использовали объекты
Пока вы проходили эти примеры, вы вероятно заметили, что точечная запись, которую вы использовали, выглядит очень знакомо. Это потому, что вы использовали её на протяжении всего курса! Каждый раз, когда мы работаем над примером, использующим встроенный API браузера или объект JavaScript, мы использовали объекты, потому что такие функции построены с использованием тех же структур объектов, которые мы здесь рассматривали, хотя и более сложные, чем наши собственные пользовательские примеры.
Поэтому, когда вы использовали строковые методы, такие как:
.split(",");
Вы использовали метод доступный в экземпляре класса String . Каждый раз создавая строку в вашем коде, эта строка автоматически создаётся как экземпляр String , и поэтому имеет несколько общих методов/свойств, доступных на нем.
Когда вы обращались к объектной модели документа (DOM), используя следующие строки:
const myDiv = document.createElement("div"); const myVideo = document.querySelector("video");
Вы использовали методы доступные в экземпляре класса Document . Для каждой загруженной веб-страницы создаётся экземпляр Document , называемый document , который представляет всю структуру страницы, её содержимое и другие функции, такие как URL-адрес. Опять же, это означает, что он имеет несколько общих методов/свойств, доступных на нем.
То же самое относится и к любому другому встроенному объекту/API, который вы использовали — Array , Math , и т. д.
Обратите внимание, что встроенные объекты/API не всегда создают экземпляры объектов автоматически. Как пример, Notifications API — который позволяет новым браузерам запускать системные уведомления, требует, чтобы вы создавали новый экземпляр объекта с помощью конструктора для каждого уведомления, которое вы хотите запустить. Попробуйте ввести следующее в консоль JavaScript:
const myNotification = new Notification("Hello!");
Опять же, мы рассмотрим конструкторы в следующей статье.
Примечание: Полезно подумать о том, как объекты взаимодействуют посредством передачи сообщений — когда объекту требуется другой объект для выполнения какого-либо действия, он часто отправляет сообщение другому объекту через один из его методов и ждёт ответа, который мы знаем как возвращаемое (return) значение.
Резюме
Поздравляем, вы достигли конца нашей первой статьи о объектах JS, теперь у вас должно быть хорошее представление о том, как работать с объектами в JavaScript — в том числе создавать свои собственные простые объекты. Вы также должны понимать, что объекты очень полезны в качестве структур для хранения связанных данных и функциональности — если бы мы пытались отслеживать все свойства и методы в нашем объекте person как отдельные переменные и функции, это было неэффективно, и мы бы рисковали столкнуться с другими переменными и функциями с такими же именами. Объекты позволяют нам безопасно хранить информацию в своём собственном блоке, вне опасности.
В следующей статье мы начнём рассматривать теорию объектно-ориентированного программирования (ООП) и как эти техники могут быть использованы в JavaScript
- Обзор: Введение в объекты JavaScript
- Далее
Как определить регистр символа
Здравствуйте! Подскажите, как определить регистр символа. Именно определить, а не изменить. Есть ли какая-нибудь функция? Самый простой метод в лоб — это два массива с верхний и нижним регистром, после проверка на вхождение. Есть ли путь проще?
Отслеживать
371 1 1 золотой знак 5 5 серебряных знаков 13 13 бронзовых знаков
задан 10 дек 2013 в 16:44
chessinvin chessinvin
169 1 1 золотой знак 1 1 серебряный знак 7 7 бронзовых знаков
Хорошо, что еще никто не догадался регулярное выражение использовать))
11 дек 2013 в 11:26
@lampa, к сожалению, нет: ru.stackoverflow.com/a/705517/207618
– user207618
13 авг 2017 в 12:03
7 ответов 7
Сортировка: Сброс на вариант по умолчанию
Например, так можно:
var symbol = 's'; var isUpperCase = symbol.toUpperCase()==symbol; alert(!!isUpperCase); // true - верхний регистр, false - нижний
Отслеживать
ответ дан 10 дек 2013 в 20:35
13.6k 13 13 золотых знаков 62 62 серебряных знака 122 122 бронзовых знака
Благодарю. Пожалуй, воспользуюсь Вашим вариантом!
11 дек 2013 в 15:56
На ум пришло 2 идеи:
- Сравнивать диапазон ASCII кодов символов, если входит в диапазон — значит верхний регистр, иначе нижний. Сложность в том, что тут придется учитывать разные кодировки, или приводить символ\текст к нужной.
- Воспользоваться функцие приводящей к верхнему\нижнему регистру. Пример допустимый для PHP:
В JS у строки есть метод — toUpperCase().
Отслеживать
ответ дан 10 дек 2013 в 17:52
510 4 4 серебряных знака 10 10 бронзовых знаков
Первый вариант, мне кажется, наиболее правильный. Только «иначе нижний» не совсем верно, может быть вовсе не буква. И быть внимательным, т.к. букву ё вечно все недолюбливают.
11 дек 2013 в 4:11
@pincher1519 чем плохо ? «ёлки палки. Что такое с этим ё».split(»).map(function(v,i) < if (v.toUpperCase()==v.toLowerCase()) return '#'; return v==v.toUpperCase()?"U":"l">);
11 дек 2013 в 4:31
@pincher1519, получится, что Щ — это строчная буква
11 дек 2013 в 5:28
@pincher1519 > А разве нельзя сравнить, если ch >= ‘A’ и ch <= 'Z', то заглавная? сравните подобным образом utf8 строку и получите национальную индийскую премию по программированию. >само собой нужно это ещё сделать и для русского алфавита, и отдельно для буквы ё. зачем это все если есть .toUpperCase ?
11 дек 2013 в 10:05
@pincher1519 какая такая банальная проверка ? вы предлагаете 500 условий вставить на каждый язык, .toUpperCase() написана на си и учитывает правила перевода символа в utf8 для всех языков. Горе программист это вы — вместо того чтобы использовать стандартную функцию, городите велосипед. (а вы случайно не складываете числа ассемблерными вставками ?), кстати заметьте — я свои слова подтверждаю кодом, а вы даже не пробовали свою процедуру написать, ибо когда попробуете — увидите насколько ужасна она будет при банальном требовании совместимости английский, немецкий, русский.
11 дек 2013 в 10:50
На днях столкнулся с такой же задачей. Предлагаю свою идею. В ходе написание скрипта были учтены непереводимые в регистр символы, цифры, пробел. При определении ввода верхнего регистра проверяю последний введенный символ.
Ну в общем чего ходить вокруг да около вот функция которая принимает объект и уже на типу объекта берет значение для проверки.
/** * return boolean * true - using Caps Lock * false - not using Caps Lock **/ function checkingUp(_obj) < var symbol = ''; var type = _obj[0].tagName; switch(type) < case "INPUT" : symbol = String(_obj.val()); break; >if(symbol == '') < return false; >symbol = symbol.substr(symbol.length - 1, (symbol.length)); if($.isNumeric(symbol)) < return false; >var newSymbol = symbol.toLowerCase(); if(symbol != newSymbol) < return true; >return false; > Функция принимает String значение для проверки.
/** * return boolean * true - using Caps Lock * false - not using Caps Lock **/ function checkingUp(_obj) < var symbol = _obj; if(symbol == '')< return false; >symbol = symbol.substr(symbol.length - 1, (symbol.length)); if($.isNumeric(symbol)) < return false; >var newSymbol = symbol.toLowerCase(); if(symbol != newSymbol) < return true; >return false; > Функция может быть использована для проверки вводимого значения в поле Password, примерный код проверки с использованием вышеизложенной функции прилаживая ниже . . .
$("#login-form input[type=password]").each(function() < // после поля ввода пароля расположен span с логотипом капчи, скрытый стилями css var iconCapsLock = $(this).parent().find('.capslock'); $(this).bind('keyup', function()< if(checkingUp($(this)))< iconCapsLock.show(); >else < iconCapsLock.hide(); >>); $(this).bind('blur', function()< iconCapsLock.hide(); >); >);
И под конец пример HTML верстки с полем для проверки
Надеюсь, что мой совет поможет нуждающимся ))