Полезные функции и методы
Полезные функции и методы
В повседневной разработке программисты постоянно взаимодействуют с встроенными функциями и методами стандартных библиотек. Эти инструменты позволяют решать типовые задачи без написания кода с нуля: обработка строк, работа с коллекциями, манипуляции с датами, преобразование данных, математические вычисления и многое другое. Знание наиболее часто используемых функций каждого языка значительно повышает продуктивность и читаемость кода.
Ниже представлен обширный справочный раздел, охватывающий ключевые встроенные функции и методы в шести популярных языках программирования: Python, JavaScript, C#, Java, PHP, Kotlin, Go и Rust. Для каждой категории приведены аналогичные операции в разных языках, что помогает разработчикам, знакомым с одним языком, быстрее освоить другой.
Работа со строками
Строки — один из самых часто используемых типов данных. Операции над ними включают поиск подстрок, замену, разбиение, объединение, проверку содержимого и форматирование.
Python
text = "Hello, World!"
# Проверка наличия подстроки
"Hello" in text # True
# Поиск позиции
text.find("World") # 7
text.index("World") # 7 (выбрасывает исключение при отсутствии)
# Замена
text.replace("World", "Python") # "Hello, Python!"
# Разбиение и объединение
text.split(", ") # ["Hello", "World!"]
" ".join(["Hello", "Python"]) # "Hello Python"
# Регистр
text.upper() # "HELLO, WORLD!"
text.lower() # "hello, world!"
text.capitalize() # "Hello, world!"
text.title() # "Hello, World!"
# Удаление пробелов
" text ".strip() # "text"
" text ".lstrip() # "text "
" text ".rstrip() # " text"
# Проверки
text.startswith("Hello") # True
text.endswith("!") # True
text.isalpha() # False (из-за запятой и пробела)
text.isdigit() # False
JavaScript
const text = "Hello, World!";
// Проверка наличия подстроки
text.includes("Hello"); // true
// Поиск позиции
text.indexOf("World"); // 7
text.lastIndexOf("o"); // 8
// Замена
text.replace("World", "JavaScript"); // "Hello, JavaScript!"
text.replaceAll("l", "L"); // "HeLLo, WorLd!"
// Разбиение и объединение
text.split(", "); // ["Hello", "World!"]
["Hello", "JavaScript"].join(" "); // "Hello JavaScript"
// Регистр
text.toUpperCase(); // "HELLO, WORLD!"
text.toLowerCase(); // "hello, world!"
// Удаление пробелов
" text ".trim(); // "text"
" text ".trimStart(); // "text "
" text ".trimEnd(); // " text"
// Проверки
text.startsWith("Hello"); // true
text.endsWith("!"); // true
C#
string text = "Hello, World!";
// Проверка наличия подстроки
text.Contains("Hello"); // true
// Поиск позиции
text.IndexOf("World"); // 7
text.LastIndexOf("o"); // 8
// Замена
text.Replace("World", "C#"); // "Hello, C#!"
// Разбиение и объединение
text.Split(", "); // ["Hello", "World!"]
string.Join(" ", new[] { "Hello", "C#" }); // "Hello C#"
// Регистр
text.ToUpper(); // "HELLO, WORLD!"
text.ToLower(); // "hello, world!"
// Удаление пробелов
" text ".Trim(); // "text"
" text ".TrimStart(); // "text "
" text ".TrimEnd(); // " text"
// Проверки
text.StartsWith("Hello"); // true
text.EndsWith("!"); // true
Java
String text = "Hello, World!";
// Проверка наличия подстроки
text.contains("Hello"); // true
// Поиск позиции
text.indexOf("World"); // 7
text.lastIndexOf("o"); // 8
// Замена
text.replace("World", "Java"); // "Hello, Java!"
text.replaceAll("l", "L"); // "HeLLo, WorLd!"
// Разбиение и объединение
text.split(", "); // ["Hello", "World!"]
String.join(" ", "Hello", "Java"); // "Hello Java"
// Регистр
text.toUpperCase(); // "HELLO, WORLD!"
text.toLowerCase(); // "hello, world!"
// Удаление пробелов
" text ".trim(); // "text"
" text ".strip(); // "text" (Java 11+)
// Проверки
text.startsWith("Hello"); // true
text.endsWith("!"); // true
PHP
$text = "Hello, World!";
// Проверка наличия подстроки
strpos($text, "Hello") !== false; // true
// Поиск позиции
strpos($text, "World"); // 7
strrpos($text, "o"); // 8
// Замена
str_replace("World", "PHP", $text); // "Hello, PHP!"
// Разбиение и объединение
explode(", ", $text); // ["Hello", "World!"]
implode(" ", ["Hello", "PHP"]); // "Hello PHP"
// Регистр
strtoupper($text); // "HELLO, WORLD!"
strtolower($text); // "hello, world!"
// Удаление пробелов
trim(" text "); // "text"
ltrim(" text "); // "text "
rtrim(" text "); // " text"
// Проверки
str_starts_with($text, "Hello"); // true (PHP 8+)
str_ends_with($text, "!"); // true (PHP 8+)
Kotlin
val text = "Hello, World!"
// Проверка наличия подстроки
"Hello" in text // true
// Поиск позиции
text.indexOf("World") // 7
text.lastIndexOf("o") // 8
// Замена
text.replace("World", "Kotlin") // "Hello, Kotlin!"
// Разбиение и объединение
text.split(", ") // [Hello, World!]
listOf("Hello", "Kotlin").joinToString(" ") // "Hello Kotlin"
// Регистр
text.uppercase() // "HELLO, WORLD!"
text.lowercase() // "hello, world!"
// Удаление пробелов
" text ".trim() // "text"
// Проверки
text.startsWith("Hello") // true
text.endsWith("!") // true
Go
package main
import (
"strings"
)
func main() {
text := "Hello, World!"
// Проверка наличия подстроки
strings.Contains(text, "Hello") // true
// Поиск позиции
strings.Index(text, "World") // 7
strings.LastIndex(text, "o") // 8
// Замена
strings.Replace(text, "World", "Go", -1) // "Hello, Go!"
// Разбиение и объединение
strings.Split(text, ", ") // ["Hello" "World!"]
strings.Join([]string{"Hello", "Go"}, " ") // "Hello Go"
// Регистр
strings.ToUpper(text) // "HELLO, WORLD!"
strings.ToLower(text) // "hello, world!"
// Удаление пробелов
strings.TrimSpace(" text ") // "text"
// Проверки
strings.HasPrefix(text, "Hello") // true
strings.HasSuffix(text, "!") // true
}
Rust
let text = "Hello, World!";
// Проверка наличия подстроки
text.contains("Hello"); // true
// Поиск позиции
text.find("World"); // Some(7)
text.rfind("o"); // Some(8)
// Замена
text.replace("World", "Rust"); // "Hello, Rust!"
// Разбиение и объединение
text.split(", ").collect::<Vec<&str>>(); // ["Hello", "World!"]
["Hello", "Rust"].join(" "); // "Hello Rust"
// Регистр
text.to_uppercase(); // "HELLO, WORLD!"
text.to_lowercase(); // "hello, world!"
// Удаление пробелов
" text ".trim(); // "text"
// Проверки
text.starts_with("Hello"); // true
text.ends_with("!"); // true
Работа с коллекциями
Коллекции (массивы, списки, словари, множества) используются для хранения и обработки групп данных. Основные операции включают добавление, удаление, фильтрацию, сортировку, агрегацию и трансформацию элементов.
Python
# Списки
numbers = [1, 2, 3, 4, 5]
# Добавление и удаление
numbers.append(6) # [1, 2, 3, 4, 5, 6]
numbers.pop() # 6, numbers = [1, 2, 3, 4, 5]
numbers.remove(3) # [1, 2, 4, 5]
# Фильтрация и трансформация
evens = [x for x in numbers if x % 2 == 0] # [2, 4]
squared = [x**2 for x in numbers] # [1, 4, 9, 16, 25]
# Агрегация
sum(numbers) # 15
max(numbers) # 5
min(numbers) # 1
len(numbers) # 5
# Сортировка
sorted(numbers, reverse=True) # [5, 4, 2, 1]
# Словари
person = {"name": "Alice", "age": 30}
person.keys() # dict_keys(['name', 'age'])
person.values() # dict_values(['Alice', 30])
person.items() # dict_items([('name', 'Alice'), ('age', 30)])
JavaScript
// Массивы
const numbers = [1, 2, 3, 4, 5];
// Добавление и удаление
numbers.push(6); // [1, 2, 3, 4, 5, 6]
numbers.pop(); // 6, numbers = [1, 2, 3, 4, 5]
numbers.splice(2, 1); // удаляет 1 элемент с индекса 2
// Фильтрация и трансформация
const evens = numbers.filter(x => x % 2 === 0); // [2, 4]
const squared = numbers.map(x => x * x); // [1, 4, 9, 16, 25]
// Агрегация
numbers.reduce((sum, x) => sum + x, 0); // 15
Math.max(...numbers); // 5
Math.min(...numbers); // 1
numbers.length; // 5
// Сортировка
[...numbers].sort((a, b) => b - a); // [5, 4, 3, 2, 1]
// Объекты
const person = { name: "Alice", age: 30 };
Object.keys(person); // ["name", "age"]
Object.values(person); // ["Alice", 30]
Object.entries(person); // [["name", "Alice"], ["age", 30]]
C#
using Система.Linq;
// Списки
var numbers = new List<int> { 1, 2, 3, 4, 5 };
// Добавление и удаление
numbers.Add(6); // [1, 2, 3, 4, 5, 6]
numbers.RemoveAt(numbers.Count - 1); // удаляет последний
numbers.Remove(3); // удаляет первое вхождение 3
// Фильтрация и трансформация
var evens = numbers.Where(x => x % 2 == 0).ToList(); // [2, 4]
var squared = numbers.Select(x => x * x).ToList(); // [1, 4, 9, 16, 25]
// Агрегация
numbers.Sum(); // 15
numbers.Max(); // 5
numbers.Min(); // 1
numbers.Count; // 5
// Сортировка
numbers.OrderByDescending(x => x).ToList(); // [5, 4, 2, 1]
// Словари
var person = new Dictionary<string, object>
{
{ "name", "Alice" },
{ "age", 30 }
};
person.Keys; // коллекция ключей
person.Values; // коллекция значений
Java
import java.util.*;
import java.util.stream.Collectors;
// Списки
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> mutableNumbers = new ArrayList<>(numbers);
// Добавление и удаление
mutableNumbers.add(6); // [1, 2, 3, 4, 5, 6]
mutableNumbers.remove(mutableNumbers.size() - 1); // удаляет последний
mutableNumbers.remove(Integer.valueOf(3)); // удаляет значение 3
// Фильтрация и трансформация
List<Integer> evens = mutableNumbers.stream()
.filter(x -> x % 2 == 0)
.collect(Collectors.toList()); // [2, 4]
List<Integer> squared = mutableNumbers.stream()
.map(x -> x * x)
.collect(Collectors.toList()); // [1, 4, 9, 16, 25]
// Агрегация
mutableNumbers.stream().mapToInt(Integer::intValue).sum(); // 15
Collections.max(mutableNumbers); // 5
Collections.min(mutableNumbers); // 1
mutableNumbers.size(); // 5
// Сортировка
mutableNumbers.stream()
.sorted(Collections.reverseOrder())
.collect(Collectors.toList()); // [5, 4, 2, 1]
// Словари
Map<String, Object> person = new HashMap<>();
person.put("name", "Alice");
person.put("age", 30);
person.keySet(); // набор ключей
person.values(); // коллекция значений
PHP
// Массивы
$numbers = [1, 2, 3, 4, 5];
// Добавление и удаление
$numbers[] = 6; // [1, 2, 3, 4, 5, 6]
array_pop($numbers); // 6, $numbers = [1, 2, 3, 4, 5]
unset($numbers[2]); // удаляет элемент с индексом 2
$numbers = array_values($numbers); // переиндексирует
// Фильтрация и трансформация
$evens = array_filter($numbers, fn($x) => $x % 2 == 0); // [2, 4]
$squared = array_map(fn($x) => $x * $x, $numbers); // [1, 4, 9, 16, 25]
// Агрегация
array_sum($numbers); // 15
max($numbers); // 5
min($numbers); // 1
count($numbers); // 5
// Сортировка
rsort($numbers); // сортирует по убыванию
// Ассоциативные массивы
$person = ["name" => "Alice", "age" => 30];
array_keys($person); // ["name", "age"]
array_values($person); // ["Alice", 30]
Kotlin
// Списки
val numbers = mutableListOf(1, 2, 3, 4, 5)
// Добавление и удаление
numbers.add(6) // [1, 2, 3, 4, 5, 6]
numbers.removeAt(numbers.lastIndex) // удаляет последний
numbers.remove(3) // удаляет значение 3
// Фильтрация и трансформация
val evens = numbers.filter { it % 2 == 0 } // [2, 4]
val squared = numbers.map { it * it } // [1, 4, 9, 16, 25]
// Агрегация
numbers.sum() // 15
numbers.maxOrNull() // 5
numbers.minOrNull() // 1
numbers.size // 5
// Сортировка
numbers.sortedDescending() // [5, 4, 2, 1]
// Словари
val person = mutableMapOf("name" to "Alice", "age" to 30)
person.keys // набор ключей
person.values // коллекция значений
Go
package main
import (
"sort"
)
func main() {
// Срезы
numbers := []int{1, 2, 3, 4, 5}
// Добавление
numbers = append(numbers, 6) // [1, 2, 3, 4, 5, 6]
// Удаление (по индексу)
index := 2
numbers = append(numbers[:index], numbers[index+1:]...)
// Фильтрация и трансформация (вручную или через пакеты)
evens := make([]int, 0)
for _, n := range numbers {
if n%2 == 0 {
evens = append(evens, n)
}
}
squared := make([]int, len(numbers))
for i, n := range numbers {
squared[i] = n * n
}
// Агрегация
sum := 0
max := numbers[0]
min := numbers[0]
for _, n := range numbers {
sum += n
if n > max { max = n }
if n < min { min = n }
}
// Сортировка
sort.Ints(numbers) // по возрастанию
sort.Sort(sort.Reverse(sort.IntSlice(numbers))) // по убыванию
// Словари (map)
person := map[string]interface{}{
"name": "Alice",
"age": 30,
}
// Go не предоставляет встроенных методов для получения ключей/значений
// нужно использовать циклы
}
Rust
// Векторы
let mut numbers = vec![1, 2, 3, 4, 5];
// Добавление
numbers.push(6); // [1, 2, 3, 4, 5, 6]
// Удаление (по индексу)
numbers.remove(2); // удаляет элемент с индексом 2
// Фильтрация и трансформация
let evens: Vec<i32> = numbers.iter()
.filter(|&&x| x % 2 == 0)
.cloned()
.collect();
let squared: Vec<i32> = numbers.iter()
.map(|&x| x * x)
.collect();
// Агрегация
let sum: i32 = numbers.iter().sum();
let max = numbers.iter().max().unwrap();
let min = numbers.iter().min().unwrap();
let len = numbers.len();
// Сортировка
let mut sorted = numbers.clone();
sorted.sort(); // по возрастанию
sorted.sort_by(|a, b| b.cmp(a)); // по убыванию
// Хэш-таблицы
use std::collections::HashMap;
let mut person = HashMap::new();
person.insert("name", "Alice");
person.insert("age", "30");
// Rust не предоставляет удобных методов для получения всех ключей/значений
// нужно использовать итераторы
Работа с датами и временем
Корректная обработка временных меток, форматирование дат, вычисление разницы между моментами времени — типичные задачи в разработке приложений любого уровня.
Python
from datetime import datetime, timedelta
# Текущее время
now = datetime.now()
# Парсинг строки в дату
dt = datetime.strptime("2025-12-31", "%Y-%m-%d")
# Форматирование даты
formatted = now.strftime("%d.%m.%Y %H:%M")
# Добавление времени
future = now + timedelta(days=7)
# Разница между датами
diff = future - now # timedelta объект
JavaScript
// Текущее время
const now = new Date();
// Создание из строки
const dt = new Date("2025-12-31");
// Форматирование (локализованное)
const formatted = now.toLocaleString("ru-RU");
// Добавление дней
const future = new Date(now);
future.setDate(future.getDate() + 7);
// Разница в миллисекундах
const diffMs = future - now;
const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
C#
// Текущее время
DateTime now = DateTime.Now;
// Парсинг
DateTime dt = DateTime.Parse("2025-12-31");
// Форматирование
string formatted = now.ToString("dd.MM.yyyy HH:mm");
// Добавление времени
DateTime future = now.AddDays(7);
// Разница
TimeSpan diff = future - now;
int days = diff.Days;
Java
import java.time.*;
// Текущее время
LocalDateTime now = LocalDateTime.now();
// Парсинг
LocalDateTime dt = LocalDateTime.parse("2025-12-31T00:00");
// Форматирование
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm");
String formatted = now.format(formatter);
// Добавление времени
LocalDateTime future = now.plusDays(7);
// Разница
Duration diff = Duration.between(now, future);
long days = diff.toDays();
PHP
// Текущее время
$now = new DateTime();
// Парсинг
$dt = new DateTime("2025-12-31");
// Форматирование
$formatted = $now->format("d.m.Y H:i");
// Добавление времени
$future = clone $now;
$future->modify("+7 days");
// Разница
$diff = $now->diff($future); // DateInterval
$days = $diff->days;
Kotlin
import java.time.*
val now = LocalDateTime.now()
val dt = LocalDateTime.parse("2025-12-31T00:00")
val formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm")
val formatted = now.format(formatter)
val future = now.plusDays(7)
val diff = Duration.between(now, future)
val days = diff.toDays()
Go
package main
import (
"time"
)
func main() {
now := time.Now()
dt, _ := time.Parse("2006-01-02", "2025-12-31")
formatted := now.Format("02.01.2006 15:04")
future := now.AddDate(0, 0, 7)
diff := future.Sub(now)
days := int(diff.Hours() / 24)
}
Rust
use chrono::{DateTime, Local, NaiveDate, Duration};
let now: DateTime<Local> = Local::now();
let dt = NaiveDate::from_ymd_opt(2025, 12, 31).unwrap().and_hms_opt(0, 0, 0).unwrap();
let formatted = now.format("%d.%m.%Y %H:%M").to_string();
let future = now + Duration::days(7);
let diff = (future - now).num_days();
Математические операции
Базовые арифметические действия, округления, генерация случайных чисел и тригонометрические функции часто требуются даже в простых приложениях.
Python
import math
import random
# Арифметика
result = 10 / 3 # 3.333...
floor_val = math.floor(result) # 3
ceil_val = math.ceil(result) # 4
round_val = round(result, 2) # 3.33
# Случайные числа
rand_int = random.randint(1, 100)
rand_float = random.random() # [0.0, 1.0)
# Тригонометрия
angle = math.radians(45)
sin_val = math.sin(angle)
JavaScript
// Арифметика
const result = 10 / 3;
const floorVal = Math.floor(result);
const ceilVal = Math.ceil(result);
const roundVal = Math.round(result * 100) / 100; // 3.33
// Случайные числа
const randInt = Math.floor(Math.random() * 100) + 1;
const randFloat = Math.random(); // [0, 1)
// Тригонометрия
const angle = 45 * Math.PI / 180;
const sinVal = Math.sin(angle);
C#
using Система;
double result = 10.0 / 3.0;
double floorVal = Math.Floor(result);
double ceilVal = Math.Ceiling(result);
double roundVal = Math.Round(result, 2);
// Случайные числа
Random rand = new Random();
int randInt = rand.Next(1, 101); // верхняя граница не включена
double randFloat = rand.NextDouble(); // [0.0, 1.0)
// Тригонометрия
double angle = 45 * Math.PI / 180;
double sinVal = Math.Sin(angle);
Java
import java.util.Random;
double result = 10.0 / 3.0;
double floorVal = Math.floor(result);
double ceilVal = Math.ceil(result);
double roundVal = Math.round(result * 100) / 100.0;
Random rand = new Random();
int randInt = rand.nextInt(100) + 1;
double randFloat = rand.nextDouble(); // [0.0, 1.0)
double angle = Math.toRadians(45);
double sinVal = Math.sin(angle);
PHP
$result = 10 / 3;
$floorVal = floor($result);
$ceilVal = ceil($result);
$roundVal = round($result, 2);
$randInt = rand(1, 100);
$randFloat = mt_rand() / mt_getrandmax(); // [0, 1]
$angle = deg2rad(45);
$sinVal = sin($angle);
Kotlin
import kotlin.math.*
import kotlin.random.Random
val result = 10.0 / 3.0
val floorVal = floor(result)
val ceilVal = ceil(result)
val roundVal = "%.2f".format(result).toDouble() // или используйте DecimalFormat
val randInt = Random.nextInt(1, 101)
val randFloat = Random.nextDouble() // [0.0, 1.0)
val angle = Math.toRadians(45.0)
val sinVal = sin(angle)
Go
package main
import (
"math"
"math/rand"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
result := 10.0 / 3.0
floorVal := math.Floor(result)
ceilVal := math.Ceil(result)
roundVal := math.Round(result*100) / 100
randInt := rand.Intn(100) + 1
randFloat := rand.Float64() // [0.0, 1.0)
angle := 45 * math.Pi / 180
sinVal := math.Sin(angle)
}
Rust
use rand::Rng;
use std::f64::consts::PI;
let result = 10.0 / 3.0;
let floor_val = result.floor();
let ceil_val = result.ceil();
let round_val = (result * 100.0).round() / 100.0;
let mut rng = rand::thread_rng();
let rand_int: u32 = rng.gen_range(1..=100);
let rand_float: f64 = rng.gen(); // [0.0, 1.0)
let angle = 45.0 * PI / 180.0;
let sin_val = angle.sin();
Ввод и вывод
Взаимодействие с пользователем, чтение файлов, запись логов — фундаментальные операции ввода-вывода.
Python
# Консоль
name = input("Имя: ")
print("Привет,", name)
# Файл
with open("Данные.txt", "r") as f:
content = f.read()
with open("output.txt", "w") as f:
f.write("Hello")
JavaScript (Node.js)
const fs = require("fs");
// Консоль
process.stdout.write("Имя: ");
process.stdin.on("Данные", (Данные) => {
console.log("Привет,", Данные.toString().trim());
process.exit();
});
// Файл
const content = fs.readFileSync("Данные.txt", "utf8");
fs.writeFileSync("output.txt", "Hello");
C#
// Консоль
Console.Write("Имя: ");
string name = Console.ReadLine();
Console.WriteLine($"Привет, {name}");
// Файл
string content = File.ReadAllText("Данные.txt");
File.WriteAllText("output.txt", "Hello");
Java
import java.io.*;
import java.util.Scanner;
// Консоль
Scanner scanner = new Scanner(System.in);
System.out.print("Имя: ");
String name = scanner.nextLine();
System.out.println("Привет, " + name);
// Файл
String content = Files.readString(Paths.get("Данные.txt"));
Files.writeString(Paths.get("output.txt"), "Hello");
PHP
// Консоль (в CLI)
echo "Имя: ";
$name = trim(fgets(STDIN));
echo "Привет, $name\n";
// Файл
$content = file_get_contents("Данные.txt");
file_put_contents("output.txt", "Hello");
Kotlin
// Консоль
print("Имя: ")
val name = readLine()
println("Привет, $name")
// Файл
val content = File("Данные.txt").readText()
File("output.txt").writeText("Hello")
Go
package main
import (
"bufio"
"fmt"
"os"
)
func main() {
// Консоль
fmt.Print("Имя: ")
reader := bufio.NewReader(os.Stdin)
name, _ := reader.ReadString('\n')
fmt.Printf("Привет, %s", name)
// Файл
content, _ := os.ReadFile("Данные.txt")
os.WriteFile("output.txt", []byte("Hello"), 0644)
}
Rust
use std::fs;
use std::io::{self, Write};
fn main() {
// Консоль
print!("Имя: ");
io::stdout().flush().unwrap();
let mut name = String::new();
io::stdin().read_line(&mut name).unwrap();
println!("Привет, {}", name.trim());
// Файл
let content = fs::read_to_string("Данные.txt").unwrap();
fs::write("output.txt", "Hello").unwrap();
}
Обработка ошибок
Корректная обработка исключений — ключевой элемент надёжного кода. Разные языки предлагают различные подходы: от классических try-catch до явного возврата ошибок.
Python
try:
result = 10 / 0
except ZeroDivisionError as e:
print("Ошибка деления на ноль:", e)
except Exception as e:
print("Неизвестная ошибка:", e)
finally:
print("Блок finally всегда выполняется")
JavaScript
try {
JSON.parse("{ invalid json }");
} catch (e) {
console.error("Ошибка парсинга JSON:", e.message);
} finally {
console.log("Блок finally всегда выполняется");
}
C#
try
{
int result = 10 / 0;
}
catch (DivideByZeroException e)
{
Console.WriteLine($"Ошибка деления на ноль: {e.Message}");
}
catch (Exception e)
{
Console.WriteLine($"Неизвестная ошибка: {e.Message}");
}
finally
{
Console.WriteLine("Блок finally всегда выполняется");
}
Java
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Ошибка деления на ноль: " + e.getMessage());
} catch (Exception e) {
System.out.println("Неизвестная ошибка: " + e.getMessage());
} finally {
System.out.println("Блок finally всегда выполняется");
}
PHP
try {
$result = 10 / 0;
} catch (DivisionByZeroError $e) {
echo "Ошибка деления на ноль: " . $e->getMessage();
} catch (Throwable $e) {
echo "Неизвестная ошибка: " . $e->getMessage();
} finally {
echo "Блок finally всегда выполняется";
}
Kotlin
try {
val result = 10 / 0
} catch (e: ArithmeticException) {
println("Ошибка деления на ноль: ${e.message}")
} catch (e: Exception) {
println("Неизвестная ошибка: ${e.message}")
} finally {
println("Блок finally всегда выполняется")
}
Go
// Go не использует исключения; ошибки возвращаются как значения
func divide(a, b int) (int, error) {
if b == 0 {
return 0, errors.New("деление на ноль")
}
return a / b, nil
}
result, err := divide(10, 0)
if err != nil {
fmt.Println("Ошибка:", err)
}
Rust
// Rust использует тип Result<T, E> вместо исключений
fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
if b == 0 {
Err("деление на ноль")
} else {
Ok(a / b)
}
}
match divide(10, 0) {
Ok(result) => println!("Результат: {}", result),
Err(e) => println!("Ошибка: {}", e),
}
Функциональные конструкции
Многие языки поддерживают функциональный стиль программирования: передача функций как значений, каррирование, композиция и т.д.
Python
# Лямбда-функции
square = lambda x: x * x
numbers = [1, 2, 3, 4]
squared = list(map(square, numbers))
# partial application
from functools import partial
def multiply(x, y):
return x * y
double = partial(multiply, 2)
JavaScript
// Стрелочные функции
const square = x => x * x;
const numbers = [1, 2, 3, 4];
const squared = numbers.map(square);
// Каррирование
const multiply = x => y => x * y;
const double = multiply(2);
C#
// Лямбды и делегаты
Func<int, int> square = x => x * x;
var numbers = new[] { 1, 2, 3, 4 };
var squared = numbers.Select(square).ToArray();
// Partial application через замыкание
Func<int, int> Multiply(int x) => y => x * y;
var doubleFunc = Multiply(2);
Java
// Функциональные интерфейсы
Function<Integer, Integer> square = x -> x * x;
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<Integer> squared = numbers.stream().map(square).collect(Collectors.toList());
// Методы не поддерживают прямое каррирование, но можно эмулировать
Kotlin
val square: (Int) -> Int = { x -> x * x }
val numbers = listOf(1, 2, 3, 4)
val squared = numbers.map(square)
// Каррирование
fun multiply(x: Int) = { y: Int -> x * y }
val double = multiply(2)
Go
// Функции как значения
square := func(x int) int { return x * x }
numbers := []int{1, 2, 3, 4}
squared := make([]int, len(numbers))
for i, n := range numbers {
squared[i] = square(n)
}
Rust
// Замыкания
let square = |x: i32| x * x;
let numbers = vec![1, 2, 3, 4];
let squared: Vec<i32> = numbers.iter().map(|&x| square(x)).collect();
// Функции высшего порядка
fn apply<F>(f: F, x: i32) -> i32
where
F: Fn(i32) -> i32,
{
f(x)
}
Работа с файлами
Чтение и запись файлов — одна из самых частых задач при разработке приложений.
Python
# Чтение
with open("file.txt", "r", encoding="utf-8") as f:
content = f.read()
# Запись
with open("output.txt", "w", encoding="utf-8") as f:
f.write("Hello")
# Проверка существования
import os
if os.path.exists("file.txt"):
print("Файл существует")
JavaScript (Node.js)
const fs = require("fs");
// Чтение
const content = fs.readFileSync("file.txt", "utf8");
// Запись
fs.writeFileSync("output.txt", "Hello");
// Проверка существования
if (fs.existsSync("file.txt")) {
console.log("Файл существует");
}
C#
// Чтение
string content = File.ReadAllText("file.txt");
// Запись
File.WriteAllText("output.txt", "Hello");
// Проверка существования
if (File.Exists("file.txt")) {
Console.WriteLine("Файл существует");
}
Java
// Чтение
String content = Files.readString(Paths.get("file.txt"));
// Запись
Files.writeString(Paths.get("output.txt"), "Hello");
// Проверка существования
if (Files.exists(Paths.get("file.txt"))) {
System.out.println("Файл существует");
}
PHP
// Чтение
$content = file_get_contents("file.txt");
// Запись
file_put_contents("output.txt", "Hello");
// Проверка существования
if (file_exists("file.txt")) {
echo "Файл существует";
}
Kotlin
// Чтение
val content = File("file.txt").readText()
// Запись
File("output.txt").writeText("Hello")
// Проверка существования
if (File("file.txt").exists()) {
println("Файл существует")
}
Go
// Чтение
content, _ := os.ReadFile("file.txt")
// Запись
os.WriteFile("output.txt", []byte("Hello"), 0644)
// Проверка существования
if _, err := os.Stat("file.txt"); !os.IsNotExist(err) {
fmt.Println("Файл существует")
}
Rust
// Чтение
let content = fs::read_to_string("file.txt").unwrap();
// Запись
fs::write("output.txt", "Hello").unwrap();
// Проверка существования
if Path::new("file.txt").exists() {
println!("Файл существует");
}
Многопоточность и асинхронность
Современные приложения часто требуют одновременного выполнения нескольких задач: загрузка данных, обработка пользовательского ввода, фоновые вычисления. Для этого используются механизмы многопоточности и асинхронного программирования.
Python
import threading
import asyncio
# Многопоточность
def worker():
print("Работа в потоке")
thread = threading.Thread(target=worker)
thread.start()
thread.join()
# Асинхронность
async def async_task():
await asyncio.sleep(1)
return "Готово"
result = asyncio.run(async_task())
JavaScript
// Асинхронность (Promise и async/await)
async function fetchData() {
const response = await fetch('/api/Данные');
const Данные = await response.json();
return Данные;
}
// Web Workers для тяжелых вычислений (в браузере)
const worker = new Worker('worker.js');
worker.postMessage('start');
worker.onmessage = (e) => console.log(e.Данные);
C#
using Система.Threading.Задачи;
// Асинхронность
public async Task<string> FetchDataAsync()
{
await Task.Delay(1000);
return "Готово";
}
// Многопоточность через Task
Task.Run(() => Console.WriteLine("Фоновая задача"));
Java
import java.util.concurrent.CompletableFuture;
// Многопоточность
new Thread(() -> System.out.println("Работа в потоке")).start();
// Асинхронность
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
return "Готово";
});
String result = future.get();
PHP
// PHP не поддерживает нативную многопоточность, но можно использовать:
// - pcntl_fork() (только в CLI)
// - Amp или ReactPHP для асинхронности
// Пример с ReactPHP (псевдокод)
$loop = React\EventLoop\Factory::create();
$loop->addTimer(1, function () {
echo "Асинхронная задача\n";
});
$loop->run();
Kotlin
import kotlinx.coroutines.*
// Асинхронность
suspend fun fetchData(): String {
delay(1000)
return "Готово"
}
runBlocking {
val result = fetchData()
}
Go
package main
import (
"fmt"
"time"
)
func worker() {
fmt.Println("Работа в горутине")
}
func main() {
// Горутины (легковесные потоки)
go worker()
time.Sleep(100 * time.Millisecond)
}
Rust
use tokio;
// Асинхронность (с использованием Tokio)
#[tokio::main]
async fn main() {
tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
println!("Готово");
}
// Многопоточность (стандартная библиотека)
use std::thread;
thread::spawn(|| println!("Работа в потоке"));
Утилиты для отладки и профилирования
Отладка и анализ производительности — ключевые этапы разработки. Каждый язык предоставляет инструменты для логирования, измерения времени выполнения и анализа использования памяти.
Python
import logging
import time
import cProfile
# Логирование
logging.basicConfig(level=logging.INFO)
logging.info("Сообщение")
# Замер времени
start = time.time()
# ... код ...
elapsed = time.time() - start
# Профилирование
cProfile.run('your_function()')
JavaScript
// Консоль
console.log("Отладка");
console.time("операция");
// ... код ...
console.timeEnd("операция");
// Профилирование в DevTools (браузер)
performance.mark("start");
// ... код ...
performance.mark("end");
performance.measure("операция", "start", "end");
C#
using Система.Diagnostics;
// Логирование
Система.Diagnostics.Debug.WriteLine("Отладка");
// Замер времени
var sw = Stopwatch.StartNew();
// ... код ...
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
// Профилирование — через Visual Studio Diagnostic Tools
Java
import java.util.logging.Logger;
// Логирование
Logger logger = Logger.getLogger("MyApp");
logger.info("Сообщение");
// Замер времени
long start = Система.nanoTime();
// ... код ...
long elapsed = Система.nanoTime() - start;
// Профилирование — через VisualVM, JProfiler, Async-Profiler
PHP
// Логирование
error_log("Сообщение");
// Замер времени
$start = microtime(true);
// ... код ...
$elapsed = microtime(true) - $start;
// Xdebug — расширение для профилирования и отладки
Kotlin
import kotlin.Система.measureTimeMillis
// Логирование — через slf4j, logback и т.д.
println("Отладка")
// Замер времени
val elapsed = measureTimeMillis {
// ... код ...
}
Go
import (
"log"
"time"
)
// Логирование
log.Println("Сообщение")
// Замер времени
start := time.Now()
// ... код ...
elapsed := time.Since(start)
Rust
use std::time::Instant;
// Логирование — через log crate + env_logger
println!("Отладка");
// Замер времени
let start = Instant::now();
// ... код ...
let duration = start.elapsed();
Работа с типами и рефлексия
Инспекция типов во время выполнения, проверка принадлежности, преобразование — важные возможности для гибкого кода.
Python
# Проверка типа
isinstance(42, int) # True
# Получение типа
type(42) # <class 'int'>
# Рефлексия
hasattr(obj, 'method')
getattr(obj, 'method')()
JavaScript
// Проверка типа
typeof 42 === 'number'; // true
Array.isArray([]); // true
// Рефлексия
'property' in obj;
Reflect.get(obj, 'property');
C#
// Проверка типа
obj is int; // true/false
obj.GetType() == typeof(int);
// Рефлексия
var type = obj.GetType();
var method = type.GetMethod("MethodName");
method.Invoke(obj, null);
Java
// Проверка типа
obj instanceof Integer;
// Рефлексия
Class<?> clazz = obj.getClass();
Method method = clazz.getMethod("methodName");
method.invoke(obj);
PHP
// Проверка типа
is_int(42); // true
gettype(42); // "integer"
// Рефлексия
$reflection = new ReflectionClass($obj);
$method = $reflection->getMethod('methodName');
$method->invoke($obj);
Kotlin
// Проверка типа
obj is Int
// Рефлексия (требуется kotlin-reflect)
val klass = obj::class
val method = klass.memberFunctions.find { it.name == "methodName" }
method?.call(obj)
Go
import "reflect"
// Проверка типа через утверждение интерфейса
if val, ok := obj.(int); ok {
// val — int
}
// Рефлексия
t := reflect.TypeOf(obj)
v := reflect.ValueOf(obj)
method := v.MethodByName("MethodName")
method.Call(nil)
Rust
// Rust не поддерживает классическую рефлексию.
// Но можно использовать трейты и макросы.
// Проверка типа — через паттерн матчинга или трейты
match value {
MyType::Variant(x) => { /* обработка */ },
_ => {}
}
// Для динамической информации — Any трейт
use std::any::Any;
fn is_int(value: &dyn Any) -> bool {
value.is::<i32>()
}
Преобразование типов и проверка значений
Часто требуется привести значение одного типа к другому: число к строке, строку к логическому значению, объект к JSON и т.п. Также важно уметь проверять корректность входных данных.
Python
# Преобразование
str(42) # "42"
int("123") # 123
float("3.14") # 3.14
bool("text") # True
bool("") # False
# Проверка
isinstance(42, int) # True
"123".isdigit() # True
"abc".isalpha() # True
JavaScript
// Преобразование
String(42) // "42"
Number("123") // 123
parseFloat("3.14") // 3.14
Boolean("text") // true
!!"text" // true (альтернатива)
// Проверка
typeof 42 === "number" // true
isNaN("abc") // true
Number.isInteger(42) // true
C#
// Преобразование
Convert.ToString(42); // "42"
int.Parse("123"); // 123
int.TryParse("123", out int result); // безопасный парсинг
bool.Parse("True"); // true
// Проверка
int.TryParse("abc", out _); // false
value is int; // true/false
Java
// Преобразование
String.valueOf(42); // "42"
Integer.parseInt("123"); // 123
Double.parseDouble("3.14");
Boolean.parseBoolean("true");
// Проверка
"123".matches("\\d+"); // true
Character.isDigit('5'); // true
PHP
// Преобразование
(strval)(42); // "42"
intval("123"); // 123
floatval("3.14"); // 3.14
(bool)"text"; // true
// Проверка
is_numeric("123"); // true
ctype_digit("123"); // true
filter_var("email@example.com", FILTER_VALIDATE_EMAIL);
Kotlin
// Преобразование
42.toString() // "42"
"123".toInt() // 123
"3.14".toDouble() // 3.14
"true".toBoolean() // true
// Проверка
"123".toIntOrNull() != null // true
value is Int // true/false
Go
import "strconv"
// Преобразование
strconv.Itoa(42) // "42"
strconv.Atoi("123") // 123, error
strconv.ParseFloat("3.14", 64)
// Проверка — через возврат ошибки
_, err := strconv.Atoi("abc")
if err != nil { /* недопустимое число */ }
Rust
// Преобразование
42.to_string(); // "42"
"123".parse::<i32>().unwrap(); // 123
"3.14".parse::<f64>().unwrap();
// Проверка — через Result
match "abc".parse::<i32>() {
Ok(_) => println!("число"),
Err(_) => println!("не число"),
}
Работа с JSON
Обмен данными в формате JSON — стандарт де-факто в современных приложениях.
Python
import json
Данные = {"name": "Alice"}
json_str = json.dumps(Данные)
parsed = json.loads(json_str)
JavaScript
const Данные = { name: "Alice" };
const jsonStr = JSON.stringify(Данные);
const parsed = JSON.parse(jsonStr);
C#
using Система.Text.Json;
var Данные = new { Name = "Alice" };
string jsonStr = JsonSerializer.Serialize(Данные);
var parsed = JsonSerializer.Deserialize<Dictionary<string, object>>(jsonStr);
Java
import com.fasterxml.jackson.databind.ObjectMapper;
ObjectMapper mapper = new ObjectMapper();
String jsonStr = mapper.writeValueAsString(Данные);
MyClass obj = mapper.readValue(jsonStr, MyClass.class);
PHP
$Данные = ["name" => "Alice"];
$jsonStr = json_encode($Данные);
$parsed = json_decode($jsonStr, true);
Kotlin
import kotlinx.serialization.json.*
val json = Json.encodeToString(MyData("Alice"))
val parsed = Json.decodeFromString<MyData>(json)
Go
import "encoding/json"
Данные := map[string]string{"name": "Alice"}
jsonData, _ := json.Marshal(Данные)
var parsed map[string]interface{}
json.Unmarshal(jsonData, &parsed)
Rust
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
struct Person { name: String }
let person = Person { name: "Alice".to_string() };
let json_str = serde_json::to_string(&person).unwrap();
let parsed: Person = serde_json::from_str(&json_str).unwrap();
Валидация и санитизация
Безопасная обработка пользовательского ввода — обязательная практика.
Python
import re
email_pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
re.match(email_pattern, "test@example.com")
JavaScript
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
emailRegex.test("test@example.com");
C#
using Система.Text.RegularExpressions;
Regex.IsMatch("test@example.com", @"^[^@\s]+@[^@\s]+\.[^@\s]+$");
PHP
filter_var("test@example.com", FILTER_VALIDATE_EMAIL);
Go
import "net/mail"
_, err := mail.ParseAddress("test@example.com")
if err == nil { /* валидный email */ }
См. также
Другие статьи этого же раздела в боковом меню (как на странице «О разделе»). Проблема — Пользователи должны иметь возможность регистрироваться, входить в систему и получать доступ к персонализированному контенту или функционалу. Простой консольный чат на C — это учебное приложение, демонстрирующее базовые принципы сетевого взаимодействия между клиентом и сервером с использованием сокетов. Перед началом работы обязательно изучите главу Turtle . Scratch — визуальная образовательная среда программирования, разработанная MIT Media Lab. Особенности реализации — set -euo pipefail — обязательная практика для production-скриптов; - shift $((OPTIND - 1)) корректно обрабатывает как script.sh -c ., так и script.sh . -c; - -C и… echo off rem — Отключает вывод каждой команды (как set -x в bash) rem — в начале первой строки подавляет вывод её самой Примечание — использует XML-документацию, встроенную в модули. В PowerShell 7+ справка по умолчанию загружается из интернета, если локальные файлы отсутствуют. Примечание — для большинства случаев достаточно , но оно не поддерживает функции и некоторые нестандартные объекты (например, до ES2024 — поддержка есть, но не во всех средах выполнения, например,… ✅ Такой подход даёт полную типобезопасность без и без / . Подходит для лёгких сценариев или когда внешние зависимости нежелательны. ✅ Работает, если связь или гарантируется единственность. ⚠️ Для продакшена рекомендуются Jackson ( ) или Gson (более производительные и типобезопасные). удобен для прототипирования. Генератор случайных паролей — это утилита, создающая строки с заданными криптографическими свойствами — длина, наличие заглавных и строчных букв, цифр, специальных символов.Готовые решения
Простой консольный чат на CSharp
Примеры фигур Turtle на Python
Примеры скриптов Scratch
Примеры скриптов в Linux
Примеры команд в cmd
Примеры команд в PowerShell
Примеры решений в JavaScript
Примеры решений в TypeScript
Примеры запросов в SQL
Примеры решений в Java
Генератор случайных паролей на CSharp