Как определить тип переменной в Golang?
в Go я новичок. и столкнулся с такой проблемой:
беру из бд (postgerysql) адрес сайта и пытаюсь его спарсить, но не получается. когда переменную с тем же самым адресом сайта указываю в коде (переменной) то всё работает. в базе записан адрес в колонку character(255). для парсера использую github.com/PuerkitoBio/goquery
- Вопрос задан более трёх лет назад
- 9714 просмотров
2 комментария
Оценить 2 комментария
код в студию
alst161 @alst161 Автор вопроса
Решения вопроса 1
fmt.Printf(«%T\n», var)
Ответ написан более трёх лет назад
Нравится 1 4 комментария
alst161 @alst161 Автор вопроса
оба string, значение те же. вообще не понимаю
alst161 @alst161 Автор вопроса
на первый вопрос ответ дал, спасибо)
в консоли постгри
SELECT url,name,block FROM saits
есть ли NULL среди значений?
alst161 @alst161 Автор вопроса
Владимир: неа. дело было в длине строки. вы натолкнули на эту мысль и всё решил)
Ответы на вопрос 1
alst161 @alst161 Автор вопроса
package main import ( "fmt" "database/sql" _ "github.com/lib/pq" "log" "github.com/PuerkitoBio/goquery" ) type SaitsInfo struct < s_url,s_name,s_block string >func (this SaitsInfo) view() < doc, err := goquery.NewDocument(this.s_url) if err != nil < log.Fatal(err) >doc.Find(".offers_box_table tr .txt_box2").Each(func(i int, s *goquery.Selection)< band := s.Find("a").Text() title := s.Find("span").Text() fmt.Printf("Review %d: %s - %s\n", i, band, title) >) > var ( url string name string block string ) func main() < db, err := sql.Open("postgres", "данные подключения") if err != nil < log.Fatal(err) >saits, err := db.Query(`SELECT url,name,block FROM saits`) if err != nil < log.Fatal(err) >for saits.Next() < if err := saits.Scan(&url,&name,&block); err != nil< log.Fatal(err) >si := SaitsInfo si.view() > defer db.Close() >Ответ написан более трёх лет назад
Что именно не получается-то? Сбилдить или что-то не так во время исполнения, что говорит отладчик?
alst161 @alst161 Автор вопроса
Sharp: отладчик не ругается, но когда с базы беру урл, то он просто не парсит и идёт дальше. а когда в коде указываю урл то всё отлично работает. ещё заметил особенность что переменную которую создаю в коде fmt.Printr не выводит, а переменную из базы выводит
alst161: Вы пробовали под отладчиком пройтись по каждой строчке?
Обращение к базе вроде правильно.
Просто проверьте, нет ли ошибки ,прочитывает ли хоть одну строку из базы.
У меня пока нет возможности самому запустить.
Как определить тип переменной в Golang?
str := «\n раз два три тест \n» fmt.Println(str) str23 := strings . Trim ( str , «.
package main import ( «fmt» «sort» ) type Person struct < Name string Age int >func (p Person) String.
Регулярные выражения(RegEx) — система обработки текста, основанная на специальной системе записи образцов для поиска. Образец (англ. patter.
str := «\n раз два старое тест старое \n» fmt.Println(str) str45 := strings.Replace(str, «старо.
func find_rune_number(str, char string ) [] int < // функция принимает (строку и символ) и выдаёт масиив индексов символа .
package dif import ( «time» ) var StartTime = time . Now () var I int var S string —————-.
Переменные
Ранее в этой книге мы имели дело с литеральными значениями (числами, строками и т.д.), но программы с одними только литералами фактически бесполезны. Для того, чтобы сделать по-настоящему полезные программы, нам нужно узнать о двух важных вещах: переменных и инструкциях, управляющих ходом выполнения. В этой главе будут рассмотрены переменные.
Переменная — это именованное место хранения какого-то типа данных. Давайте изменим программу, которую мы написали в главе 2 так, чтобы там использовались переменные.
package main import "fmt" func main()
Обратите внимание, что мы по-прежнему используем строковый литерал из оригинальной программы, но вместо того, чтобы напрямую передать его в функцию Println , мы присваиваем его переменной. Переменные в Go создаются с помощью ключевого слова var , за которым следуют имя переменной ( x ), тип ( string ) и присваиваемое значение ( Hello World ). Последний шаг не обязателен, поэтому программа может быть переписана так:
package main import "fmt" func main()
Переменные в Go похожи на переменные в алгебре, но есть несколько различий. Во-первых, когда мы видим символ = , то по привычке читаем его как «х равен строке Hello World». Нет ничего неверного в том, чтобы читать программу таким образом, но лучше читать это как «х принимает значение строки Hello World» или «x присваивается строка Hello World». Это различие важно потому, что переменные могут менять свои значения во время выполнения программы (как понятно по их названию). Попробуйте сделать следующее:
package main import "fmt" func main()
На самом деле вы можете сделать даже так:
var x string x = "first " fmt.Println(x) x = x + "second" fmt.Println(x) Эта программа будет бессмысленной, если вы будете читать её как теорему из алгебры. Но она обретет смысл, если вы будете внимательно читать программу как список команд. Когда мы видим x = x + «second» , то должны читать это так: «Присвоить конкатенацию значения переменной x и литерала строки переменной x». Операции справа от = выполняются первыми, и результат присваивается левой части.
Запись x = x + y настолько часто встречается в программировании, что в Go есть специальный оператор присваивания += . Мы можем записать x = x + «second» как x += «second» , и результат будет тем же (прочие операторы могут быть использованы подобным же образом).
Другое отличие между Go и алгеброй в том, что для равенства используется другой символ: == (два знака равно, один за другим). == — это оператор. Как и + , он возвращает логический тип. Например:
var x string = "hello" var y string = "world" fmt.Println(x == y) Эта программа напечатает false , потому что hello отличается от world . С другой стороны:
var x string = "hello" var y string = "hello" fmt.Println(x == y) напечатает true , потому что обе строки одинаковы.
Если мы хотим присвоить значение переменной при её создании, то можем использовать сокращенную запись:
x := "Hello World" Обратите внимание на то, что : стоит перед = , и на отсутствие типа. Тип в данном случае указывать не обязательно, так как компилятор Go способен определить тип по литералу, которым мы инициализируем переменную. Тут мы присваиваем строку, поэтому x будет иметь тип string . Компилятор может определить тип и при использовании var :
var x = "Hello World" И так со всеми типами:
x := 5 fmt.Println(x) В общем, желательно всегда использовать краткий вариант написания.
Как назвать переменную
Правильное именование переменных — важная часть разработки ПО. Имена должны начинаться с буквы и могут содержать буквы, цифры и знак _ (знак подчеркивания). Компилятору Go, в принципе, всё равно, как вы назовете переменную, но не забудьте, что вам (и может быть кому-то еще) потом это придется читать. Предположим, у нас есть:
x := "Max" fmt.Println("My dog's name is", x) В этом случае x не самое лучшее имя переменной. Лучше было бы так:
name := "Max" fmt.Println("My dog's name is", name) dogsName := "Max" fmt.Println("My dog's name is", dogsName) В последнем случае мы использовали специальный способ написания имени переменной, состоящей из нескольких слов, известный как lower CamelCase (или camelBack). Первая буква первого слова записывается в нижнем регистре, первая буква последующих слов записывается в верхнем регистре, всё остальное — в нижнем.
Область видимости
Вернемся к программе, которую мы рассматривали в начале главы:
package main import "fmt" func main()
Эту программу можно записать следующим образом:
package main import "fmt" var x string = "Hello World" func main()
Мы вынесли переменные за пределы функции main. Это означает, что теперь другие функции имеют доступ к этой переменной:
var x string = "Hello World" func main() < fmt.Println(x) >func f()
Функция f имеет доступ к переменной x . Теперь предположим, что вместо этого мы написали:
func main() < var x string = "Hello World" fmt.Println(x) >func f()
Если вы попробуете выполнить эту программу, то получите ошибку:
.\main.go:11: undefined: x Компилятор говорит вам, что переменная x внутри функции f не существует. Она существует только внутри функции main . Места, где может использоваться переменная x , называются областью видимости переменной. Согласно спецификации «в Go область видимости ограничена блоками». В основном это значит, что переменные существуют только внутри текущих фигурных скобок < >(в блоке), включая все вложенные скобки (блоки). Область видимости поначалу может запутать вас, но когда вы увидите больше примеров, то всё станет ясно.
Константы
Go также поддерживает константы. Константы — это переменные, чьи значения не могут быть изменены после инициализации. Они создаются таким же образом, как и переменные, только вместо var используется ключевое слово const :
package main import "fmt" func main()
const x string = "Hello World" x = "Some other string" вызовет ошибку компиляции:
.\main.go:7: cannot assign to x Константы — хороший способ использовать определенные значения в программе без необходимости писать их каждый раз. Например, константа Pi из пакета math .
Определение нескольких переменных
В Go существует еще одно сокращение на случай, если необходимо определить несколько переменных:
var ( a = 5 b = 10 c = 15 ) Используя ключевые слово var (или const ), за которым идут круглые скобки с одной переменной в каждой строке.
Пример программы
package main import "fmt" func main()
Тут мы используем другую функцию из пакета fmt , чтобы считать пользовательский ввод ( Scanf ). &input будет объяснен в следующих главах, а все, что нам нужно знать сейчас, это то, что Scanf заполняет переменную input числом, введенным нами.
Задачи
- Существуют два способа для создания новой переменной. Какие?
- Какое будет значение у x после выполнения x := 5; x += 1 ?
- Что такое область видимости и как определяется область видимости переменной в Go?
- В чем отличие var от const ?
- Используя пример программы выше напишите программу, переводящую температуру из градусов Фаренгейта в градусы Цельсия. ( C = (F — 32) * 5/9 )
- Напишите другую программу для перевода футов в метры (1 фут = 0.3048 метр).
Типы
В предыдущей главе мы использовали строковый тип данных, чтобы хранить Hello World . Типы данных определяют множество принимаемых значений, описывают, какие операции могут быть применены к ним, и определяют, как данные будут храниться. Поскольку типы данных могут быть сложны для понимания, мы попробуем рассмотреть их подробнее, прежде чем разбираться, как они реализованы в Go.
Предположим, у вас есть собака по имени Шарик. Тут «Шарик» — это «Собака», этот тип описывает какой-то набор свойств, присущий всем собакам. Наши рассуждения должны быть примерно следующие: у собак 4 лапы, Шарик — собака, значит, у Шарика 4 лапы. Типы данных в языках программирования работают похожим образом: у всех строк есть длина; x — строка, а значит у x есть длина.
В математике мы часто говорим о множествах. Например, ℝ (множество всех вещественных чисел) или ℕ (множество всех натуральных чисел). Каждый элемент этих множеств имеет такие же свойства, как и все прочие элементы этого множества. Например, все натуральные числа ассоциативны — «для всех натуральных чисел a, b и c выполняется: a + (b + c) = (a + b) + c и a × (b × c) = (a × b) × c »; в этом смысле множества схожи с типами данных в языках программирования тем, что все значения одного типа имеют общие свойства.
Go — это язык программирования со статической типизацией. Это означает, что переменные всегда имеют определенный тип и этот тип нельзя изменить. Статическая типизация, на первый взгляд, может показаться неудобной. Вы потратите кучу времени только на попытки исправить ошибки, не позволяющие программе скомпилироваться. Однако типы дают вам возможность понять, что именно делает программа, и помогают избежать распространённых ошибок.
В Go есть несколько встроенных типов данных, с которыми мы сейчас ознакомимся.
Числа
В Go есть несколько различных типов для представления чисел. Вообще, мы разделим числа на два различных класса: целые числа и числа с плавающей точкой.
Целые числа
Целые числа, точно так же, как их математические коллеги, — это числа без вещественной части. В отличие от десятичного представления чисел, которое используем мы, компьютеры используют двоичное представление.
Наша система строится на 10 различных цифрах. Когда мы исчерпываем доступные нам цифры, мы представляем большое число, используя новую цифру 2 (а затем 3, 4, 5, …) числа следуют одно за другим. Например, число, следующее за 9, это 10, число, следующее за 99, это 100 и так далее. Компьютеры делают то же самое, но они имеют только 2 цифры вместо 10. Поэтому, подсчет выглядит так: 0, 1, 10, 11, 100, 101, 110, 111 и так далее. Другое отличие между той системой счисления, что используем мы, и той, что использует компьютер — все типы чисел имеют строго определенный размер. У них есть ограниченное количество цифр. Поэтому четырехразрядное число может выглядеть так: 0000, 0001, 0010, 0011, 0100. В конце концов мы можем выйти за лимит, и большинство компьютеров просто вернутся к самому началу (что может стать причиной очень странного поведения программы).
В Go существуют следующие типы целых чисел: uint8 , uint16 , uint32 , uint64 , int8 , int16 , int32 и int64 . 8, 16, 32 и 64 говорит нам, сколько бит использует каждый тип. uint означает «unsigned integer» (беззнаковое целое), в то время как int означает «signed integer» (знаковое целое). Беззнаковое целое может принимать только положительные значения (или ноль). В дополнение к этому существуют два типа-псевдонима: byte (то же самое, что uint8 ) и rune (то же самое, что int32 ). Байты — очень распространенная единица измерения в компьютерах (1 байт = 8 бит, 1024 байта = 1 килобайт, 1024 килобайта = 1 мегабайт, …), и именно поэтому тип byte в Go часто используется для определения других типов. Также существует 3 машинно-зависимых целочисленных типа: uint , int и uintptr . Они машинно-зависимы, потому что их размер зависит от архитектуры используемого компьютера.
В общем, если вы работаете с целыми числами — просто используйте тип int .
Числа с плавающей точкой
Числа с плавающей точкой — это числа, которые содержат вещественную часть (вещественные числа) (1.234, 123.4, 0.00001234, 12340000). Их представление в компьютере довольно сложно и не особо необходимо для их использования. Так что мы просто должны помнить:
- Числа с плавающей точкой неточны. Бывают случаи, когда число вообще нельзя представить. Например, результатом вычисления 1.01 — 0.99 будет 0.020000000000000018 — число очень близкое к ожидаемому, но не то же самое.
- Как и целые числа, числа с плавающей точкой имеют определенный размер (32 бита или 64 бита). Использование большего размера увеличивает точность (сколько цифр мы можем использовать для вычисления)
- В дополнение к числам существуют несколько других значений, таких как: «not a number» (не число) ( NaN , для вещей наподобие 0/0 ), а также положительная и отрицательная бесконечность ( +∞ и −∞ ).
В Go есть два вещественных типа: float32 и float64 (соответственно, часто называемые вещественными числами с одинарной и двойной точностью). А также два дополнительных типа для представления комплексных чисел (чисел с мнимой частью): complex64 и complex128 . Как правило, мы должны придерживаться типа float64 , когда работаем с числами с плавающей точкой.
Пример
Давайте напишем программу-пример, использующую числа. Во-первых, создайте папку «chapter3» с файлом main.go внутри со следующим содержимым:
package main import "fmt" func main() < fmt.Println("1 + 1 highlight">$ go run main.go 1 + 1 = 2
Заметим, что эта программа очень схожа с программой, которую мы написали в главе 2. Она содержит ту же строку с указанием пакета, ту же строку с импортом, то же определение функции и использует ту же функцию Println . В этот раз вместо печати строки Hello World мы печатаем строку 1 + 1 = с последующим результатом выражения 1 + 1 . Это выражение состоит из трех частей: числового литерала 1 (который является типом int ), оператора + (который представляет сложение) и другого числового литерала 1 . Давайте попробуем сделать то же самое, используя числа с плавающей точкой:
fmt.Println("1 + 1 highlight">package main import "fmt" func main()
- Пробел тоже считается символом, поэтому длина строки 11 символов, а не 10 и третья строка содержит "Hello " вместо "Hello" .
- Строки “индексируются” начиная с 0, а не с 1. [1] даст вам второй элемент, а не первый. Также заметьте, что вы видите 101 вместо e , когда выполняете программу. Это происходит из-за того, что символ представляется байтом (помните, байт — это целое число). Можно думать об индексации так: "Hello World" 1 . Читайте это так: «строка Hello World позиция 1», «на 1 позиции строки Hello World» или «второй символ строки Hello World».
- Конкатенация использует тот же символ, что и сложение. Компилятор Go выясняет, что должно происходить, полагаясь на типы аргументов. Если по обе стороны от + находятся строки, компилятор предположит, что вы имели в виду конкатенацию, а не сложение (ведь сложение для строк бессмысленно).
Логические типы
Булевский тип (названный так в честь Джорджа Буля) — это специальный однобитный целочисленный тип, используемый для представления истинности и ложности. С этим типом используются три логических оператора:
Литерал
Пояснение
&&
И
||
ИЛИ
!
НЕ
Вот пример программы, показывающей их использование:
func main()
Запуск этой программы должен вывести:
$ go run main.go true false true true false
Используем таблицы истинности, чтобы определить, как эти операторы работают:
Выражение
Значение
true && true
true
true && false
false
false && true
false
false && false
false
Выражение
Значение
true || true
true
true || false
true
false || true
true
false || false
false
Выражение
Значение
!true
false
!false
true
Всё это — простейшие типы, включенные в Go и являющиеся основой, с помощью которой строятся все остальные типы.
Задачи
- Как хранятся числа в компьютере?
- Мы знаем, что в десятичной системе самое большое число из одной цифры - это 9, а из двух - 99. В бинарной системе самое большое число из двух цифр это 11 (3), самое большое число из трех цифр это 111 (7) и самое большое число из 4 цифр это 1111 (15). Вопрос: каково самое большое число из 8 цифр? (Подсказка: 101-1=9 и 102-1=99)
- В зависимости от задачи вы можете использовать Go как калькулятор. Напишите программу, которая вычисляет 32132 × 42452 и печатает это в терминал (используйте оператор * для умножения).
- Что такое строка? Как найти её длину?
- Какое значение примет выражение (true && false) || (false && true) || !(false && false) ?