Указатели
Указатели представляют собой объекты, значением которых служат адреса других объектов (например, переменных).
Указатель определяется как обычная переменная, только перед типом данных ставится символ звездочки *. Например, определение указателя на объект типа int:
var p *int
Этому указателю можно присвоить адрес переменной типа int. Для получения адреса применяется операция & , после которой указывается имя переменной ( &x ).
package main import "fmt" func main() < var x int = 4 // определяем переменную var p *int // определяем указатель p = &x // указатель получает адрес переменной fmt.Println(p) // значение самого указателя - адрес переменной x >
Здесь указатель p хранит адрес переменной x. Что важно, переменная x имеет тип int, и указатель p указывает именно на объект типа int. То есть должно быть соответствие по типу. И если мы попробуем вывести адрес переменной на консоль, то увидим, что он представляет шестнадцатеричное значение:
0xc0420120a0
В каждом отдельном случае адрес может отличаться, но к примеру, в моем случае машинный адрес переменной x — 0xc0420120a0. То есть в памяти компьютера есть адрес 0xc0420120a0, по которому располагается переменная x.
По адресу, который хранит указатель, мы получить значение переменной x. Для этого применяется операция * или операция разыменования. Результатом этой операции является значение переменной, на которую указывает указатель. Применим данную операцию и получим значение переменной x:
package main import "fmt" func main() < var x int = 4 var p *int = &x // указатель получает адрес переменной fmt.Println("Address:", p) // значение указателя - адрес переменной x fmt.Println("Value:", *p) // значение переменной x >
Address: 0xc0420c058 Value: 4
И также используя указатель, мы можем менять значение по адресу, который хранится в указателе:
var x int = 4 var p *int = &x *p = 25 fmt.Println(x) // 25
Для определения указателей можно использовать также сокращенную форму:
f := 2.3 pf := &f fmt.Println("Address:", pf) fmt.Println("Value:", *pf)
Пустой указатель
Если указателю не присвоен адрес какого-либо объекта, то такой указатель по умолчанию имеет значение nil (по сути отстутствие значения). Если мы попробуем получить значение по такому пустому указателю, то мы столкнемся с ошибкой:
var pf *float64 fmt.Println("Value:", *pf) // ! ошибка, указатель не указывает на какой-либо объект
Поэтому при работе с указателями иногда бывает целесообразано проверять на значение nil:
var pf *float64 if pf != nil
Функция new
Переменная представляет именованный объект в памяти. Язык Go также позволяет создавать безымянные объекты — они также размещаются в памяти, но не имеют имени как переменные. Для этого применяется функция new(type) . В эту функцию передается тип, объект которого надо создать. Функция возвращает указатель на созданный объект:
package main import "fmt" func main() < p := new(int) fmt.Println("Value:", *p) // Value: 0 - значение по умолчанию *p = 8 // изменяем значение fmt.Println("Value:", *p) // Value: 8 >
В данном случае указатель p будет иметь тип *int , поскольку он указывает на объект типа int. Создаваемый объект имеет значение по умолчанию (для типа int это число 0).
Объект, созданный с помощью функции new, ничем не отличается от обычной переменной. Единственное что, чтобы обратиться к этому объекту — получить или изменить его адрес, необходимо использовать указатель.
Конструктор, оператор «new»
Обычный синтаксис <. >позволяет создать только один объект. Но зачастую нам нужно создать множество похожих, однотипных объектов, таких как пользователи, элементы меню и так далее.
Это можно сделать при помощи функции-конструктора и оператора «new» .
Функция-конструктор
Функции-конструкторы технически являются обычными функциями. Но есть два соглашения:
- Имя функции-конструктора должно начинаться с большой буквы.
- Функция-конструктор должна выполняться только с помощью оператора «new» .
function User(name) < this.name = name; this.isAdmin = false; >let user = new User("Jack"); alert(user.name); // Jack alert(user.isAdmin); // falseКогда функция вызывается как new User(. ) , происходит следующее:
- Создаётся новый пустой объект, и он присваивается this .
- Выполняется тело функции. Обычно оно модифицирует this , добавляя туда новые свойства.
- Возвращается значение this .
Другими словами, new User(. ) делает что-то вроде:
function User(name) < // this = <>; (неявно) // добавляет свойства к this this.name = name; this.isAdmin = false; // return this; (неявно) >Таким образом, let user = new User(«Jack») возвращает тот же результат, что и:
let user = < name: "Jack", isAdmin: false >;Теперь, если нам будет необходимо создать других пользователей, мы можем просто вызвать new User(«Ann») , new User(«Alice») и так далее. Данная конструкция гораздо удобнее и читабельнее, чем многократное создание литерала объекта.
Это и является основной целью конструкторов – реализовать код для многократного создания однотипных объектов.
Давайте ещё раз отметим – технически любая функция (кроме стрелочных функций, поскольку у них нет this ) может использоваться в качестве конструктора. Его можно запустить с помощью new , и он выполнит выше указанный алгоритм. Подобные функции должны начинаться с заглавной буквы – это общепринятое соглашение, чтобы было ясно, что функция должна вызываться с помощью «new».
new function() < … >
Если в нашем коде присутствует большое количество строк, создающих один сложный объект, то мы можем обернуть их в функцию-конструктор, которая будет немедленно вызвана, вот так:
// создаём функцию и сразу же вызываем её с помощью new let user = new function() < this.name = "John"; this.isAdmin = false; // . другой код для создания пользователя // возможна любая сложная логика и инструкции // локальные переменные и так далее >;Такой конструктор не может быть вызван снова, так как он нигде не сохраняется, просто создаётся и тут же вызывается. Таким образом, этот трюк направлен на инкапсуляцию кода, который создаёт отдельный объект, без возможности повторного использования в будущем.
Проверка на вызов в режиме конструктора: new.target
Продвинутая возможность
Синтаксис из этого раздела используется крайне редко. Вы можете пропустить его, если не хотите углубляться в детали языка.
Используя специальное свойство new.target внутри функции, мы можем проверить, вызвана ли функция при помощи оператора new или без него.
В случае обычного вызова функции new.target будет undefined . Если же она была вызвана при помощи new , new.target будет равен самой функции.
function User() < alert(new.target); >// без "new": User(); // undefined // с "new": new User(); // function User
Это можно использовать внутри функции, чтобы узнать, была ли она вызвана при помощи new , «в режиме конструктора», или без него, «в обычном режиме».
Также мы можем сделать, чтобы вызовы с new и без него делали одно и то же:
function User(name) < if (!new.target) < // в случае, если вы вызвали меня без оператора new return new User(name); // . я добавлю new за вас >this.name = name; > let john = User("John"); // переадресовывает вызов на new User alert(john.name); // JohnТакой подход иногда используется в библиотеках, чтобы сделать синтаксис более гибким. Чтобы люди могли вызывать функцию с new и без него, и она все ещё могла работать.
Впрочем, вероятно, это не очень хорошая практика использовать этот трюк везде, так как отсутствие new может ввести разработчика в заблуждение. С new мы точно знаем, что создаётся новый объект.
Возврат значения из конструктора, return
Обычно конструкторы не имеют оператора return . Их задача – записать все необходимое в this , и это автоматически становится результатом.
Но если return всё же есть, то применяется простое правило:
- При вызове return с объектом, вместо this вернётся объект.
- При вызове return с примитивным значением, оно проигнорируется.
Другими словами, return с объектом возвращает этот объект, во всех остальных случаях возвращается this .
К примеру, здесь return замещает this , возвращая объект:
function BigUser() < this.name = "John"; return < name: "Godzilla" >; // alert( new BigUser().name ); // Godzilla, получили этот объектА вот пример с пустым return (или мы могли бы поставить примитив после return , неважно):
function SmallUser() < this.name = "John"; return; // alert( new SmallUser().name ); // JohnОбычно у конструкторов отсутствует return . Здесь мы упомянули особое поведение с возвращаемыми объектами в основном для полноты картины.
Пропуск скобок
Кстати, мы можем не ставить круглые скобки после new :
let user = new User; // Пропуск скобок считается плохой практикой, но просто чтобы вы знали, такой синтаксис разрешён спецификацией.
Создание методов в конструкторе
Использование конструкторов для создания объектов даёт большую гибкость. Функции-конструкторы могут иметь параметры, определяющие, как создавать объект и что в него записывать.
Конечно, мы можем добавить к this не только свойства, но и методы.
Например, new User(name) ниже создаёт объект с заданным name и методом sayHi :
function User(name) < this.name = name; this.sayHi = function() < alert( "Меня зовут: " + this.name ); >; > let john = new User("John"); john.sayHi(); // Меня зовут: John /* john = < name: "John", sayHi: function() < . >> */Для создания сложных объектов есть и более продвинутый синтаксис – классы, который мы рассмотрим позже.
Итого
- Функции-конструкторы или просто конструкторы, являются обычными функциями, но существует общепринятое соглашение именовать их с заглавной буквы.
- Функции-конструкторы следует вызывать только с помощью new . Такой вызов подразумевает создание пустого this в начале и возврат заполненного в конце.
Мы можем использовать конструкторы для создания множества похожих объектов.
JavaScript предоставляет функции-конструкторы для множества встроенных объектов языка: таких как Date , Set , и других, которые нам ещё предстоит изучить.
Мы ещё вернёмся к объектам!
В этой главе мы рассмотрели только основы объектов и конструкторов. Данная информация необходима нам для дальнейшего изучения типов данных и функций в последующих главах.
Как только мы с ними разберёмся, мы вернёмся к объектам для более детального изучения в главах Прототипы, наследование и Классы.
Указатели в Golang
Хотя смысл указателя в Go весьма простой даже опытные разработчики допускают ошибки, когда используют указатели. Возможно проблема в специфическом синтаксисе, который к нам пришёл из далёкого прошлого. Амперсанд & и звёздочка * не самые выразительные операторы. Кроме этого, звёздочка * используется в определении типа указателя, как оператор разыменования указателя и для умножения значений.
Ниже собрана вся необходимая информация, о которой следует помнить, чтобы правильно применять указатели в Go.
В различных книгах и публикация встречаются следующие определения указателя Go:
Указатель — это переменная, которая хранит ссылку на другую переменную.
Указатель — это местоположение в памяти, где хранится значение. Значение указателя — это адрес переменной.
Указатели указывают на участок в памяти, где хранится значение.
Тип данных, называемый указатель, хранит адрес данных в памяти, но не сами данные.
Все 4 определения верные, мне больше нравится второе и четвёртое.
Для работы с указателями существует 2 оператора — амперсанд & и звёздочка *, а так же одна функция — new(T).
& — оператор взятия адреса.
Создадим переменную типа int со значением равным 1.
x := 1
Используем оператор & для взятия адреса переменной x.
p := &x
Теперь p хранит адрес переменной x. p имеет тип *int и указывает на переменную x.
*int — тип указатель на целое число.
Как получить значение переменной, на которую указывает p?
Очень просто, нужно перед p написать *.
Как изменить значение переменной, на которую указывает p?
Оператор звёздочка * используется в 2-х случаях:
- Для того, чтобы определить тип указателя.
В примерах выше мы работали с указателем типа *int. Но могут быть и другие типы, например *string, []*byte и т.п.
2. Для того, чтобы получить значение переменной, на которую указывает указатель. В первом примере fmt.Println(*p) мы получаем значение переменной. Именно значение, а не адрес, на который указывает указатель p. Звёздочка заставляет программу вернуть нам значение переменной, на которую ссылается указатель p.
Когда оператор * используется для получения значения переменной, на которую указывает указатель говорят, что выполняется операция разыменования.
Звёздочка — это оператор разыменования. Запомните данный термин, он часто встречается.
«Указывает указатель», «указатель указывает» такие выражения режут слух, но трудно подобрать им замену. Поэтому всё же не будем отказываться от данной тавтологии.
Функция new
func new(Type) *Type
Создать указатель можно при помощи функции new. В качестве аргумента передаётся тип Type. Функция выделяет память и возвращает указатель типа *Type с установленным значением по умолчанию для данного типа Type. Обратите внимание, в функцию new мы передаём тип Type без *.
x := new(int)
В результате мы получим указатель x типа *int, который будет иметь значение 0.
fmt.Println(*x) // Получим 0. Это значение по умолчанию для переменной типа int. Чтобы получить значение выполняем операцию разыменования указателя.
Функция new создаёт неименованную переменную (безымянный объект) типа Type и инициализирует её нулевым значением типа Type и возвращает указатель типа *Type.
Никаких других отличий переменная созданная при помощи new иметь не будет.
fmt.Println(x) // Получим адрес памяти, где хранится значение 0. Например, вывод может выглядеть так 0xc000100010.
Теперь давайте рассмотрит другой пример. Передадим в функцию new тип указателя *int.
f := new(*int)
В результате мы получим указатель f типа *int, который будет иметь нулевое значение nil.
fmt.Println(*f) // Получим nil>. Чтобы получить значение выполняем операцию разыменования указателя.
О нулевом значении указателя читайте дальше.
Нулевое значение указателя
Нулевое значение указателя любого типа равно nil.
var z *int
Мы определили тип переменной указателя, но не определили местоположение памяти, где находится значение. Поэтому, наш указатель типа *int имеет значение nil или нулевое значение.
fmt.Println(z) // Вывод —
Рассмотрим другой пример:
var k int
Мы объявили переменную k, её тип int. Значение этой переменной равняется 0.
Выражение &k даст указатель на целочисленную переменную, то есть значение типа *int.
fmt.Println(&k) // Получаем адрес памяти, где хранится значение. Вывод может выглядеть так 0xc00001c2c8.
Все переменные в Golang всегда имеют нулевое значение (значение по умолчанию). Указатели — не исключение. Если объявить указатель с каким-либо типом, но значение не присвоить, то такой указатель будет иметь нулевое значение nil.
В результате мы получим ошибку:
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x49169f]
goroutine 1 [running]:
main.main()
/tmp/sandbox593021857/prog.go:11 +0x1f
Наш указатель u создан, но он не указывает на какой-либо адрес памяти, он имеет нулевое значение. Программа не может найти место, где можно было бы сохранить целое число 10.
Изменим нашу программу.
Хорошей практикой является проверка аргумента указателя на равенство nil. Это защитит программу от генерации паники.
Указатель всегда можно проверить на равенство nil.
Передача аргументов в функцию по значению или по ссылке
А зачем нам нужны указатели? Какая от них польза?
Чтобы ответить на эти вопросы нужно разобраться в способах передачи данных в функции.
Существует 2 способа передачи данных в функцию:
В этом случае будет создана копия значения переданного аргумента и любые изменения копии этой переменной внутри функции не повлияют на значение переменой, которая была передана в функцию.
2. Передать указатель на переменную.
При передаче указателя копия значения создаваться не будет. Все изменения переменной внутри функции, на которую указывает указатель, отразиться на значении переданной в функцию переменной.
То есть, в этом случае не произойдёт выделения памяти для копии значения переменой. Это важно учитывать, когда в функцию нужно передать большой аргумент.
Но не стоит делать вывод, что передача указателей способна повысить производительность. Здесь не так всё просто.
Как лучше передать значение в функцию зависит от размера аргумента, от того, нужно ли вам после выполнения функции работать с его изменённым значением.
Решение о передаче указателя или отправке значения зависит от того, требуется ли изменить это значение. Если вы не хотите, чтобы значение изменялось, то отправьте его как значение. Если вы хотите, чтобы функция, куда вы передаете переменную, могла изменять эту переменную, вы должны передавать ее как указатель.
Получатели указателей методов
В языке Go переменной получателем или приемником называют аргумент, который определён в декларации метода.
Результатом работы это программы будет строка:
Hi! Text
Структура Foo имеет метод AddText, в котором приемником является переменная f типа Foo.
Мы можем в качестве приемника использовать указатель типа *Foo.
func (f *Foo) AddText(text string) string return f.bar + " " + text
>
Больше в программе менять ничего не потребуется. Результат выполнения не измениться.
Тогда в чём же разница между приемником значением и приемником указателем?
Предположим у нас есть структура типа Home. Для неё мы определили метод OpenDoor, в котором приемником является значение. Так вот, мы не сможем внести изменения в экземпляр структуры Home при помощи метода OpenDoor.
Результат работы программы будет такой:
Мы не смогли при помощи метода OpenDoor изменить значение IsOpenDoor.
Но, если мы добавим в программу всего один символ, то результат будет именно том, который нам нужен.
Добавим звёздочку в определение приемника метода OpenDoor.
// OpenDoor - открывает дверь
func (h *Home) OpenDoor() h.IsOpenDoor = true
>
Запустим программу и получим:
Значение поля IsOpenDoor изменено. Наша дверь открыта.
При написании программ на Go необходимо придерживаться следующего соглашения:
Если какой-либо метод типа Type имеет получатель-указатель, то и все другие методы типа Type должны иметь должны иметь указатель в качестве получателя, даже те, для которых это не требуется.
Используемые материалы
- Язык программирования Go, Донован Алан А. А., Google, Керниган Брайан У., Принстонский университет.
- The Little Go Book от Karl Seguin.
- Gopher Guides is a training and consulting company specializing in Go and Go related technologies. Co-founder:s Mark Bates & Cory LaNou. https://www.digitalocean.com/community/users/gopherguides
Как сравнить строки в Java? Сравниваем строки в Java
В этой статье мы рассмотрим операторы и методы сравнения строк в Java. Поговорим про особенности использования оператора == , а также про методы equals(), equalsIgnoreCase и compareTo(), т. к. они используются чаще всего.
Оператор для сравнения строк «==»
В первую очередь, надо сказать, что этот оператор проверяет и сравнивает не значения, а ссылки. С его помощью вы сможете проверить, являются ли сравниваемые вами элементы одним и тем же объектом. Когда 2 переменные String указывают на тот же самый объект в памяти, сравнение вернёт true, в обратном случае — false.
"Java" == "Java" //trueВ примере выше литералы интернируются компилятором, в результате чего ссылаются на один и тот же объект.
new String("Java") == "Java" // falseВышеприведённые переменные String указывают уже на различные объекты.
new String("Java") == new String("Java") // falseЗдесь тоже вышеприведенные переменные String указывают на различные объекты.
Итак, мы видим, что оператор == по сути, сравнивает не две строки, а лишь ссылки, на которые указывают строки.
class TestClass< public static void main (String[] args)< // ссылается на тот же объект, возвращая true if( "Java" == "Java" )< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// указывает уже на другой объект, возвращая false if(new String("Java") == "Java")< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// указывает тоже на другой объект, возвращая false if(new String("Java") == new String("Java") )< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >> >Итог:
Statement is true Statement is false Statement is falseМетод сравнения String equals()
Сравнение строк с помощью equals позволяет проверять исходное содержимое строки. Метод возвращает true, когда параметр — объект String, представляющий собой ту же строку символов, что и объект:
Objects.equals("Java", new String("Java")) //trueКогда надо выполнить проверку, имеют ли 2 строки одинаковое значение, мы можем задействовать Objects.equals() .
class TestClass< public static void main (String[] args) < String str1 = "Java"; String str2 = "Java"; String str3 = "ASP"; String str4 = "JAVA"; String str5 = new String("Java"); // оба равны и возвращают true if(str1.equals(str2))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// оба не равны и возвращают false if(str1.equals(str3))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// оба не равны и возвращают false if(str1.equals(str4))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// оба равны и возвращают true if(str1.equals(str5))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >> >Итог:
Statement is true Statement is false Statement is false Statement is trueМетод сравнения String equalsIgnoreCase()
С помощью метода equalsIgnoreCase() вы выполните сравнение строк, что называется, лексикографически, причём различия регистра будут игнорированы. Здесь значение true возвращается в том случае, если аргумент является объектом String и представляет такую же последовательность символов, что и у объекта. Прекрасное решение, если надо осуществить проверку строки на равенство, не учитывая при этом регистр.
class TestClass< public static void main (String[] args)< String str1 = "Java"; String str2 = "JAVA"; // возвращается true, ведь обе строки равны без учёта регистра if(str1.equalsIgnoreCase(str2))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >// возвращается false, т. к. учитывается регистр символов if(str1.equals(str2))< System.out.println("Statement is true"); >else < System.out.println("Statement is false"); >> >Statement is true Statement is falseМетод сравнения String compareTo()
Метод сравнения compareTo() применяется, если надо определить лексикографический порядок строк. Он выполняет сравнение значения char, действуя аналогично equals(). Когда 2 строки совпадают, compareTo() вернёт значение «ноль» (результат = 0). Сравнивая 2 строки, он вернёт положительное целое число (результат > 0), если 1-й объект String следует за 2-й строкой. Соответственно, метод вернёт отрицательный результат (результат < 0), когда 1-й объект String будет предшествовать 2-й строке:
result1 == result2 :возвращается 0; result1 > result2 :возвращается положительное значение; result1 < result2 : возвращается отрицательное значение.Приведём пример:
class TestClass < public static void main (String[] args) < String str1 = "Java"; String str2 = "Java"; String str3 = "ASP"; int val = 0; val = str1.compareTo(str2); System.out.println(val); val = str1.compareTo(str3); System.out.println(val); val = str3.compareTo(str1); System.out.println(val); >>Итог:
0 9 -9На этом всё, очень надеемся, что этот материал будет вам полезен при сравнении строк в "Джава".
При подготовке статьи использовалась публикация «String Comparison in Java».
Хотите знать больше? Приходите на курс!