Почему мне не использовать функции mysql_ * в PHP?

Нет необходимости в обновлении, если вы уверены, что не хотите обновлять версию php, но в то же время вы также не будете получать обновления безопасности, которые сделают ваш сайт более уязвимым для хакеров, что является основной причиной.

Не используйте mysql, потому что он устарел, используйте вместо него Mysqli.

Что означает устаревшее:

Это означает, что не используйте какую-то конкретную функцию / метод / функцию программного обеспечения / конкретную программную практику, это просто означает, что ее не следует использовать, потому что в этом программном обеспечении есть (или будет) лучшая альтернатива, которую следует использовать вместо .

​​При использовании устаревших функций может возникнуть несколько общих проблем:

1. Функции просто перестают работать: Приложения или скрипты могут полагаться на функции, которые просто больше не поддерживаются, поэтому используйте их улучшенные версии или альтернативу.

2. Отображаются предупреждающие сообщения об устаревании : эти сообщения обычно не мешают работе сайта. Однако в некоторых случаях они могут нарушить процесс отправки заголовков сервером.

Например: это может вызвать проблемы со входом в систему (файлы cookie / сеансы не устанавливаются должным образом) или проблемы с пересылкой (перенаправления 301/302/303).

имейте в виду, что:

-Устаревшее программное обеспечение по-прежнему является частью программного обеспечения.

-Устаревший код - это просто статус (метка) кода.

Ключевые различия в MYSQL и MYSQLI mysql *

• старый драйвер базы данных
• MySQL можно использовать только процедурно
• Нет защиты от атаки SQL-инъекции
• Устарело в PHP 5.5.0 и было удалено в PHP 7

mysqli

• новый драйвер базы данных
• В настоящее время используется
• подготовленные операторы защищают от атак

Можно определить почти все функции mysql_* с помощью mysqli или PDO. Просто включите их поверх своего старого PHP-приложения, и оно будет работать на PHP7. Мое решение здесь.

<?php

define('MYSQL_LINK', 'dbl');
$GLOBALS[MYSQL_LINK] = null;

function mysql_link($link=null) {
    return ($link === null) ? $GLOBALS[MYSQL_LINK] : $link;
}

function mysql_connect($host, $user, $pass) {
    $GLOBALS[MYSQL_LINK] = mysqli_connect($host, $user, $pass);
    return $GLOBALS[MYSQL_LINK];
}

function mysql_pconnect($host, $user, $pass) {
    return mysql_connect($host, $user, $pass);
}

function mysql_select_db($db, $link=null) {
    $link = mysql_link($link);
    return mysqli_select_db($link, $db);
}

function mysql_close($link=null) {
    $link = mysql_link($link);
    return mysqli_close($link);
}

function mysql_error($link=null) {
    $link = mysql_link($link);
    return mysqli_error($link);
}

function mysql_errno($link=null) {
    $link = mysql_link($link);
    return mysqli_errno($link);
}

function mysql_ping($link=null) {
    $link = mysql_link($link);
    return mysqli_ping($link);
}

function mysql_stat($link=null) {
    $link = mysql_link($link);
    return mysqli_stat($link);
}

function mysql_affected_rows($link=null) {
    $link = mysql_link($link);
    return mysqli_affected_rows($link);
}

function mysql_client_encoding($link=null) {
    $link = mysql_link($link);
    return mysqli_character_set_name($link);
}

function mysql_thread_id($link=null) {
    $link = mysql_link($link);
    return mysqli_thread_id($link);
}

function mysql_escape_string($string) {
    return mysql_real_escape_string($string);
}

function mysql_real_escape_string($string, $link=null) {
    $link = mysql_link($link);
    return mysqli_real_escape_string($link, $string);
}

function mysql_query($sql, $link=null) {
    $link = mysql_link($link);
    return mysqli_query($link, $sql);
}

function mysql_unbuffered_query($sql, $link=null) {
    $link = mysql_link($link);
    return mysqli_query($link, $sql, MYSQLI_USE_RESULT);
}

function mysql_set_charset($charset, $link=null){
    $link = mysql_link($link);
    return mysqli_set_charset($link, $charset);
}

function mysql_get_host_info($link=null) {
    $link = mysql_link($link);
    return mysqli_get_host_info($link);
}

function mysql_get_proto_info($link=null) {
    $link = mysql_link($link);
    return mysqli_get_proto_info($link);
}
function mysql_get_server_info($link=null) {
    $link = mysql_link($link);
    return mysqli_get_server_info($link);
}

function mysql_info($link=null) {
    $link = mysql_link($link);
    return mysqli_info($link);
}

function mysql_get_client_info() {
    $link = mysql_link();
    return mysqli_get_client_info($link);
}

function mysql_create_db($db, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    return mysqli_query($link, "CREATE DATABASE `$db`");
}

function mysql_drop_db($db, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    return mysqli_query($link, "DROP DATABASE `$db`");
}

function mysql_list_dbs($link=null) {
    $link = mysql_link($link);
    return mysqli_query($link, "SHOW DATABASES");
}

function mysql_list_fields($db, $table, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    $table = str_replace('`', '', mysqli_real_escape_string($link, $table));
    return mysqli_query($link, "SHOW COLUMNS FROM `$db`.`$table`");
}

function mysql_list_tables($db, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    return mysqli_query($link, "SHOW TABLES FROM `$db`");
}

function mysql_db_query($db, $sql, $link=null) {
    $link = mysql_link($link);
    mysqli_select_db($link, $db);
    return mysqli_query($link, $sql);
}

function mysql_fetch_row($qlink) {
    return mysqli_fetch_row($qlink);
}

function mysql_fetch_assoc($qlink) {
    return mysqli_fetch_assoc($qlink);
}

function mysql_fetch_array($qlink, $result=MYSQLI_BOTH) {
    return mysqli_fetch_array($qlink, $result);
}

function mysql_fetch_lengths($qlink) {
    return mysqli_fetch_lengths($qlink);
}

function mysql_insert_id($qlink) {
    return mysqli_insert_id($qlink);
}

function mysql_num_rows($qlink) {
    return mysqli_num_rows($qlink);
}

function mysql_num_fields($qlink) {
    return mysqli_num_fields($qlink);
}

function mysql_data_seek($qlink, $row) {
    return mysqli_data_seek($qlink, $row);
}

function mysql_field_seek($qlink, $offset) {
    return mysqli_field_seek($qlink, $offset);
}

function mysql_fetch_object($qlink, $class="stdClass", array $params=null) {
    return ($params === null)
        ? mysqli_fetch_object($qlink, $class)
        : mysqli_fetch_object($qlink, $class, $params);
}

function mysql_db_name($qlink, $row, $field='Database') {
    mysqli_data_seek($qlink, $row);
    $db = mysqli_fetch_assoc($qlink);
    return $db[$field];
}

function mysql_fetch_field($qlink, $offset=null) {
    if ($offset !== null)
        mysqli_field_seek($qlink, $offset);
    return mysqli_fetch_field($qlink);
}

function mysql_result($qlink, $offset, $field=0) {
    if ($offset !== null)
        mysqli_field_seek($qlink, $offset);
    $row = mysqli_fetch_array($qlink);
    return (!is_array($row) || !isset($row[$field]))
        ? false
        : $row[$field];
}

function mysql_field_len($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    return is_object($field) ? $field->length : false;
}

function mysql_field_name($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    if (!is_object($field))
        return false;
    return empty($field->orgname) ? $field->name : $field->orgname;
}

function mysql_field_table($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    if (!is_object($field))
        return false;
    return empty($field->orgtable) ? $field->table : $field->orgtable;
}

function mysql_field_type($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    return is_object($field) ? $field->type : false;
}

function mysql_free_result($qlink) {
    try {
        mysqli_free_result($qlink);
    } catch (Exception $e) {
        return false;
    }
    return true;
}

Я считаю приведенные выше ответы очень длинными, поэтому резюмирую:

Расширение mysqli имеет ряд преимущества, ключевые улучшения за расширение mysql:

• Объектно-ориентированный интерфейс
• Поддержка подготовленных отчетов
• Поддержка нескольких операторов
• Поддержка транзакций
• Расширенные возможности отладки
• Поддержка встроенного сервера

Источник: Обзор MySQLi

Как объяснено в ответах выше, альтернативами mysql являются mysqli и PDO (объекты данных PHP).

• API поддерживает подготовленные операторы на стороне сервера: поддерживается MYSQLi и PDO
• API поддерживает подготовленные операторы на стороне клиента: поддерживается только PDO
• API поддерживает хранимые процедуры: MySQLi и PDO
• API поддерживает несколько выражений и все функции MySQL 4.1+ - поддерживается MySQLi и в основном PDO

MySQLi и PDO были представлены в PHP 5.0, тогда как MySQL был представлен до PHP 3.0. Следует отметить, что MySQL включен в PHP5.x, хотя в более поздних версиях не рекомендуется.

Расширение MySQL является самым старым из трех и было оригинальным способом, который разработчики использовали для взаимодействия с MySQL. Это расширение устарело в пользу других двух альтернатив из-за улучшений, внесенных в более новые версии PHP и MySQL. <94465>

• MySQLi - это «улучшенное» расширение для работы с базами данных MySQL. Он использует преимущества функций, доступных в более новых версиях сервера MySQL, предоставляет разработчику как функционально-ориентированный, так и объектно-ориентированный интерфейс, а также делает несколько других отличных вещей.

• PDO предлагает API, который объединяет большую часть функциональности, которая ранее была распространена на основные расширения доступа к базам данных, то есть MySQL, PostgreSQL, SQLite, MSSQL и т. Д. Интерфейс предоставляет высокоуровневый интерфейс. объекты для программиста для работы с подключениями к базе данных, запросами и наборами результатов, а низкоуровневые драйверы осуществляют связь и обработку ресурсов с сервером базы данных. В PDO ведется много обсуждений и работы, и он считается подходящим методом работы с базами данных в современном профессиональном коде.

Простота использования

Аналитические и синтетические причины уже упоминались. Для новичков есть более серьезный стимул отказаться от использования устаревших функций mysql_.

Современные API баз данных просто проще в использовании.

В основном это связанные параметры , которые могут упростить код. А с отличными учебными пособиями (как показано выше) переход к PDO не слишком труден.

Одновременная перезапись более крупной базы кода, однако, требует времени. Смысл существования этой промежуточной альтернативы:

Эквивалентные функции pdo_ * вместо mysql_ *

Используя < pdo_mysql.php >, вы можете переключиться со старых функций mysql_ с минимальными усилиями . Он добавляет pdo_ оболочки функций, которые заменяют их mysql_ аналоги.

1. Просто include_once( "pdo_mysql.php" ); в каждом скрипте вызова, который должен взаимодействовать с базой данных.
   

2. Удалите префикс функции mysql_ везде везде и замените его на pdo_ <61594> .673503

   • mysql_ connect() становится pdo_ connect()
   • mysql_ query() становится pdo_ query()
   • mysql_ num_rows() становится pdo_ num_rows()
   • mysql_ insert_id() становится pdo_ insert_id()
   • mysql_ fetch_array() становится pdo_ fetch_array()
   • mysql_ fetch_assoc() становится pdo_ fetch_assoc()
   • mysql_ real_escape_string() становится pdo_ real_escape_string()
   • и так далее ...
     
     

3. Ваш код будет работать одинаково и в основном выглядеть одинаково:

   include_once("pdo_mysql.php"); 
   
   pdo_connect("localhost", "usrABC", "pw1234567");
   pdo_select_db("test");
   
   $result = pdo_query("SELECT title, html FROM pages");  
   
   while ($row = pdo_fetch_assoc($result)) {
       print "$row[title] - $row[html]";
   }
   

pdo_query("SELECT id, links, html, title, user, date FROM articles
   WHERE title='" . pdo_real_escape_string($title) . "' OR id='".
   pdo_real_escape_string($title) . "' AND user <> '" .
   pdo_real_escape_string($root) . "' ORDER BY date")

pdo_query("SELECT id, links, html, title, user, date FROM articles
   WHERE title=? OR id=? AND user<>? ORDER BY date", $title, $id, $root)

pdo_query("INSERT INTO pages VALUES (? ? ? ? ?)", $_POST);

function sanitize($str) {
   return trim(strip_tags(htmlentities(pdo_real_escape_string($str))));
}

$result = pdo_query("SELECT * FROM tbl");
while ($row = pdo_fetch_assoc($result)) {

foreach ($result as $row) {

$result->fetchAll();

Этот ответ написан, чтобы показать, насколько тривиально обойти плохо написанный код проверки пользователя PHP, как (и с помощью чего) работают эти атаки и как заменить старые функции MySQL безопасным подготовленным оператором - и в основном, почему пользователи StackOverflow (вероятно, с большим количеством представителей) лают на новых пользователей, которые задают вопросы по улучшению их кода.

Во-первых, не стесняйтесь создавать эту тестовую базу данных mysql (я назвал свою подготовку):

mysql> create table users(
    -> id int(2) primary key auto_increment,
    -> userid tinytext,
    -> pass tinytext);
Query OK, 0 rows affected (0.05 sec)

mysql> insert into users values(null, 'Fluffeh', 'mypass');
Query OK, 1 row affected (0.04 sec)

mysql> create user 'prepared'@'localhost' identified by 'example';
Query OK, 0 rows affected (0.01 sec)

mysql> grant all privileges on prep.* to 'prepared'@'localhost' with grant option;
Query OK, 0 rows affected (0.00 sec)

После этого мы можем перейти к нашему PHP-коду.

Предположим, что следующий сценарий представляет собой процесс проверки для администратора на веб-сайте (упрощенный, но работающий, если вы скопируете и используете его для тестирования):

<?php 

    if(!empty($_POST['user']))
    {
        $user=$_POST['user'];
    }   
    else
    {
        $user='bob';
    }
    if(!empty($_POST['pass']))
    {
        $pass=$_POST['pass'];
    }
    else
    {
        $pass='bob';
    }

    $database='prep';
    $link=mysql_connect('localhost', 'prepared', 'example');
    mysql_select_db($database) or die( "Unable to select database");

    $sql="select id, userid, pass from users where userid='$user' and pass='$pass'";
    //echo $sql."<br><br>";
    $result=mysql_query($sql);
    $isAdmin=false;
    while ($row = mysql_fetch_assoc($result)) {
        echo "My id is ".$row['id']." and my username is ".$row['userid']." and lastly, my password is ".$row['pass']."<br>";
        $isAdmin=true;
        // We have correctly matched the Username and Password
        // Lets give this person full access
    }
    if($isAdmin)
    {
        echo "The check passed. We have a verified admin!<br>";
    }
    else
    {
        echo "You could not be verified. Please try again...<br>";
    }
    mysql_close($link);

?>

<form name="exploited" method='post'>
    User: <input type='text' name='user'><br>
    Pass: <input type='text' name='pass'><br>
    <input type='submit'>
</form>

На первый взгляд кажется вполне законным.

Пользователь должен ввести логин и пароль, верно?

Великолепно, не входите в следующее:

user: bob
pass: somePass

и отправьте его.

​​Вывод будет следующим:

You could not be verified. Please try again...

Супер! Работая, как ожидалось, теперь давайте попробуем фактическое имя пользователя и пароль:

user: Fluffeh
pass: mypass

Удивительно! Всем привет, код корректно проверил админ. Это прекрасно!

Ну, не совсем. Допустим, пользователь - умный маленький человек. Допустим, это я.

Введите следующее:

user: bob
pass: n' or 1=1 or 'm=m

И вывод:

The check passed. We have a verified admin!

Поздравляю, вы только что разрешили мне войти в ваш суперзащищенный раздел только для администраторов, где я ввел ложное имя пользователя и ложный пароль. Серьезно, если вы мне не верите, создайте базу данных с кодом, который я предоставил, и запустите этот PHP-код, который, на первый взгляд, ДЕЙСТВИТЕЛЬНО, кажется, довольно хорошо проверяет имя пользователя и пароль.

Итак, в ответ, ПОЧЕМУ ВАС КРИЧИТ НА.

Итак, давайте посмотрим, что пошло не так, и почему я только что попал в вашу пещеру для суперадминистраторов. Я сделал предположение и предположил, что вы не были осторожны со своими входными данными, и просто передали их в базу данных напрямую. Я создал ввод таким образом, чтобы ИЗМЕНИТЬ запрос, который вы действительно выполняли. Итак, что это должно было быть и чем оно стало в итоге?

select id, userid, pass from users where userid='$user' and pass='$pass'

Это запрос, но когда мы заменяем переменные фактическими входными данными, которые мы использовали, мы получаем следующее:

select id, userid, pass from users where userid='bob' and pass='n' or 1=1 or 'm=m'

Посмотрите, как я построил свой «пароль» так, чтобы он сначала закрывал одинарную кавычку вокруг пароля, а затем вводил совершенно новое сравнение? Затем в целях безопасности я добавил еще одну «строку», чтобы одинарная кавычка закрылась, как и ожидалось, в исходном коде.

Однако сейчас речь идет не о том, чтобы на вас кричали люди, а о том, чтобы показать вам, как сделать ваш код более безопасным.

Итак, что пошло не так, и как мы можем это исправить?

Это классическая атака с использованием SQL-инъекции. Один из самых простых в этом отношении. По шкале векторов атаки это малыш, атакующий танк - и побеждающий.

Итак, как нам защитить ваш священный раздел администратора и сделать его красивым и безопасным? Первое, что нужно сделать, - это прекратить использовать эти действительно старые и устаревшие функции mysql_*. Я знаю, вы следовали руководству, которое нашли в Интернете, и он работает, но он старый, он устарел, и за несколько минут я только что преодолел его, даже не вспотев.

Теперь у вас есть лучшие варианты использования mysqli_ или PDO. Я лично большой поклонник PDO, поэтому в оставшейся части этого ответа я буду использовать PDO. Есть плюсы и минусы, но лично я считаю, что плюсы намного перевешивают минусы. Он переносится на несколько движков баз данных - используете ли вы MySQL или Oracle или что-нибудь еще, - просто изменив строку подключения, у него есть все причудливые функции, которые мы хотим использовать, и он приятный и чистый. Я люблю чистоту.

Теперь давайте снова посмотрим на этот код, на этот раз написанный с использованием объекта PDO:

<?php 

    if(!empty($_POST['user']))
    {
        $user=$_POST['user'];
    }   
    else
    {
        $user='bob';
    }
    if(!empty($_POST['pass']))
    {
        $pass=$_POST['pass'];
    }
    else
    {
        $pass='bob';
    }
    $isAdmin=false;

    $database='prep';
    $pdo=new PDO ('mysql:host=localhost;dbname=prep', 'prepared', 'example');
    $sql="select id, userid, pass from users where userid=:user and pass=:password";
    $myPDO = $pdo->prepare($sql, array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
    if($myPDO->execute(array(':user' => $user, ':password' => $pass)))
    {
        while($row=$myPDO->fetch(PDO::FETCH_ASSOC))
        {
            echo "My id is ".$row['id']." and my username is ".$row['userid']." and lastly, my password is ".$row['pass']."<br>";
            $isAdmin=true;
            // We have correctly matched the Username and Password
            // Lets give this person full access
        }
    }

    if($isAdmin)
    {
        echo "The check passed. We have a verified admin!<br>";
    }
    else
    {
        echo "You could not be verified. Please try again...<br>";
    }

?>

<form name="exploited" method='post'>
    User: <input type='text' name='user'><br>
    Pass: <input type='text' name='pass'><br>
    <input type='submit'>
</form>

Основные отличия заключаются в том, что больше нет функций mysql_*. Все это делается с помощью объекта PDO, во-вторых, с помощью подготовленного оператора. А что вы спросите? Это способ сообщить базе данных перед запуском запроса, какой запрос мы собираемся выполнить. В этом случае мы сообщаем базе данных: «Привет, я собираюсь запустить оператор select, требующий идентификатора, идентификатора пользователя и перехода от пользователей таблицы, где идентификатор пользователя является переменной, а проход также является переменной».

Затем в операторе execute мы передаем базе данных массив со всеми ожидаемыми переменными.

Результаты фантастические. Давайте попробуем еще раз те комбинации имени пользователя и пароля, которые были ранее:

user: bob
pass: somePass

Пользователь не подтвержден. Замечательно.

Как насчет:

user: Fluffeh
pass: mypass

О, я просто немного поволновался, это сработало: проверка прошла. У нас есть проверенный админ!

Теперь давайте попробуем данные, которые умный парень мог бы ввести, чтобы попытаться обойти нашу маленькую систему проверки:

user: bob
pass: n' or 1=1 or 'm=m

На этот раз мы получаем следующее:

You could not be verified. Please try again...

Вот почему на вас кричат, когда вы публикуете вопросы - это потому, что люди видят, что ваш код можно обойти, даже не пытаясь. Пожалуйста, используйте этот вопрос и ответ, чтобы улучшить свой код, сделать его более безопасным и использовать текущие функции.

Наконец, это не означает, что это ИДЕАЛЬНЫЙ код. Есть еще много вещей, которые вы могли бы сделать для его улучшения, например, использовать хешированные пароли, гарантировать, что, когда вы храните важную информацию в базе данных, вы не сохраняете ее в виде простого текста, имеете несколько уровней проверки - но на самом деле, если вы просто измените свой старый код, подверженный инъекциям, на это, вы будете ХОРОШО на пути к написанию хорошего кода - и тот факт, что вы зашли так далеко и все еще читаете, дает мне чувство надежды, что вы не только реализуете этот тип кода при написании ваших веб-сайтов и приложений, но вы можете пойти и изучить те другие вещи, которые я только что упомянул, и многое другое. Пишите лучший код, который вы можете, а не самый простой код, который практически не работает.

Если говорить о технических причинах, то их всего несколько, чрезвычайно конкретных и редко используемых. Скорее всего, вы никогда в жизни ими не воспользуетесь.
Возможно, я слишком невежественен, но у меня никогда не было возможности использовать такие вещи, как

• неблокирующие асинхронные запросы
• хранимые процедуры, возвращающие несколько наборов результатов
• Шифрование (SSL)
• Сжатие

Если они вам нужны - это, без сомнения, технические причины для перехода от расширения mysql к чему-то более стильному и современному.

Тем не менее, есть и некоторые нетехнические проблемы, которые могут немного усложнить ваш опыт

• дальнейшее использование этих функций с современными версиями PHP вызовет уведомления об устаревшем уровне. Их просто можно отключить.
• в далеком будущем они могут быть удалены из стандартной сборки PHP. Это тоже не имеет большого значения, поскольку mydsql ext будет перемещен в PECL, и каждый хостер будет счастлив скомпилировать PHP с ним, поскольку они не хотят терять клиентов, чьи сайты работали десятилетиями.
• сильное сопротивление со стороны сообщества Stackoverflow. Каждый раз, когда вы упоминаете эти честные функции, вам говорят, что они находятся под строгим табу.
• средний пользователь PHP, скорее всего, ваше представление об использовании этих функций подвержено ошибкам и ошибочно. Просто из-за всех этих многочисленных руководств и руководств, которые учат вас неправильному пути. Не сами функции - я должен это подчеркнуть - а то, как они используются.

Последняя проблема является проблемой.
Но, на мой взгляд, и предлагаемое решение ничем не лучше.
Мне кажется слишком идеалистическим мечтой о том, что все эти пользователи PHP сразу научатся правильно обрабатывать SQL-запросы. Скорее всего, они просто механически изменили бы mysql_ * на mysqli_ *, оставив подход таким же . Тем более, что mysqli делает использование подготовленных операторов невероятно болезненным и хлопотным.
Не говоря уже о том, что родной подготовленных операторов недостаточно для защиты от инъекций SQL, и ни mysqli, ни PDO не предлагают решения.

Итак, вместо того, чтобы бороться с этим честным расширением, я предпочел бы бороться с неправильными методами и обучать людей правильным путям.

Также есть несколько ложных или несущественных причин, например

• Не поддерживает хранимые процедуры (мы давно использовали mysql_query("CALL my_proc");)
• Не поддерживает транзакции (как указано выше)
• Не поддерживает несколько операторов (кому они нужны?)
• Не находится в активной разработке (и что? Это влияет на на вас, каким-либо образом?)
• Отсутствует объектно-ориентированный интерфейс (для его создания требуется несколько часов)
• Не поддерживает подготовленные операторы или параметризованные запросы

Последний интересный момент. Хотя mysql ext не поддерживает собственные подготовленные операторы , они не требуются для обеспечения безопасности. Мы можем легко подделать подготовленные операторы, используя ручные заполнители (как это делает PDO):

function paraQuery()
{
    $args  = func_get_args();
    $query = array_shift($args);
    $query = str_replace("%s","'%s'",$query); 

    foreach ($args as $key => $val)
    {
        $args[$key] = mysql_real_escape_string($val);
    }

    $query  = vsprintf($query, $args);
    $result = mysql_query($query);
    if (!$result)
    {
        throw new Exception(mysql_error()." [$query]");
    }
    return $result;
}

$query  = "SELECT * FROM table where a=%s AND b LIKE %s LIMIT %d";
$result = paraQuery($query, $a, "%$b%", $limit);

вуаля , все параметризовано и безопасно.

Но ладно, если вам не нравится красное поле в руководстве, возникает проблема выбора: mysqli или PDO?

Ответ будет таким:

• Если вы понимаете необходимость использования уровня абстракции базы данных и ищете API для его создания, mysqli - очень хороший выбор, поскольку он действительно поддерживает многие специфичные для MySQL. особенности.

• Если, как и подавляющее большинство разработчиков PHP, вы используете необработанные вызовы API прямо в коде приложения (что, по сути, является неправильной практикой) - PDO - единственный выбор , поскольку это расширение претендует на то, чтобы не просто API, а скорее полу-DAL, все еще неполный, но предлагающий множество важных функций, две из которых резко отличают PDO от mysqli:

  • в отличие от mysqli, PDO может связывать заполнители по значению , что делает динамически построенные запросы выполнимыми без нескольких экранов с довольно беспорядочным кодом.
  • в отличие от mysqli, PDO всегда может возвращать результат запроса в виде простого обычного массива, тогда как mysqli может делать это только на установках mysqlnd.

Итак, если вы средний пользователь PHP и хотите избавить себя от множества головных болей при использовании собственных подготовленных операторов, PDO - опять же - единственный выбор.
Однако PDO - тоже не серебряная пуля, и у него есть свои трудности.
Итак, я написал решения для всех распространенных ошибок и сложных случаев в вики тега PDO

Тем не менее, все, кто говорит о расширениях, всегда упускают 2 важных факта о Mysqli и PDO:

1. Подготовленный отчет не является серебряной пулей . Есть динамические идентификаторы, которые нельзя связать с помощью подготовленных операторов. Существуют динамические запросы с неизвестным количеством параметров, что затрудняет построение запроса.

2. Ни mysqli_ *, ни функции PDO не должны появляться в коде приложения.
   Между ними и кодом приложения должен быть уровень абстракции , который будет выполнять всю грязную работу по привязке, циклу, обработке ошибок и т. Д. Внутри, делая код приложения СУХИМ и чистым. Особенно для сложных случаев, таких как динамическое построение запросов.

Итак, просто переключиться на PDO или mysqli недостаточно. Вместо вызова необработанных функций API в их коде необходимо использовать ORM, построитель запросов или любой другой класс абстракции базы данных.
И наоборот - если у вас есть уровень абстракции между кодом вашего приложения и mysql API - , на самом деле не имеет значения, какой движок используется. Вы можете использовать mysql ext до тех пор, пока он не станет устаревшим, а затем легко переписать свой класс абстракции на другой движок, с неповрежденным кодом всего приложения.

Вот несколько примеров, основанных на моем классе safemysql, чтобы показать, каким должен быть такой класс абстракции:

$city_ids = array(1,2,3);
$cities   = $db->getCol("SELECT name FROM cities WHERE is IN(?a)", $city_ids);

Сравните эту одну строку с объемом кода, который вам понадобится с PDO.
Затем сравните с сумасшедшим количеством кода, который вам понадобится, с необработанными подготовленными операторами Mysqli. Обратите внимание, что обработка ошибок, профилирование и ведение журнала запросов уже встроены и работают.

$insert = array('name' => 'John', 'surname' => "O'Hara");
$db->query("INSERT INTO users SET ?u", $insert);

Сравните это с обычными вставками PDO, когда каждое отдельное имя поля повторяется от шести до десяти раз - во всех этих многочисленных именованных заполнителях, привязках и определениях запросов.

Другой пример:

$data = $db->getAll("SELECT * FROM goods ORDER BY ?n", $_GET['order']);

Вы вряд ли найдете пример для PDO, чтобы справиться с таким практическим случаем.
И это будет слишком многословно и, скорее всего, небезопасно.

Итак, еще раз - вас должен беспокоить не только необработанный драйвер, но и класс абстракции, полезный не только для глупых примеров из руководства для начинающих, но и для решения любых реальных проблем.

PHP предлагает три различных API для подключения к MySQL. Это mysql (удалено с PHP 7), mysqli и PDO <6542675675671323> Расширения

Функции mysql_* раньше были очень популярны, но их использование больше не приветствуется. Команда документации обсуждает ситуацию с безопасностью базы данных, и обучение пользователей отказу от широко используемого расширения ext / mysql является частью этого (проверьте php.internals: отказ от ext / mysql ).

И более поздняя команда разработчиков PHP приняла решение генерировать E_DEPRECATED ошибки, когда пользователи подключаются к MySQL через mysql_connect(), mysql_pconnect() функциональность, встроенная в ext/mysql.

ext/mysql был официально объявлен устаревшим с PHP 5.5 и удален как и удален как <567567567567567567567567 >.

Видите красную рамку?

Когда вы переходите на любую страницу руководства по функциям mysql_*, вы видите красную рамку, поясняющую, что ее больше не следует использовать.

Почему

Отказ от ext/mysql касается не только безопасности, но и доступа ко всем функциям базы данных MySQL.

ext/mysql был построен для MySQL 3.23 и с тех пор получил очень мало дополнений, в основном сохраняя совместимость с этой старой версией, что затрудняет поддержку кода. Отсутствующие функции, которые не поддерживаются ext/mysql, включают: ( из руководства PHP ).

• Хранимые процедуры (не могут обрабатывать несколько наборов результатов)
• Подготовленные отчеты
• Шифрование (SSL)
• Сжатие
• Полная поддержка кодировки

Причина отказа от использования функции mysql_* :

• Не в активной разработке
• Удалено с PHP 7
• Отсутствует интерфейс OO
• Не поддерживает неблокирующие асинхронные запросы
• Не поддерживает подготовленные операторы или параметризованные запросы
• Не поддерживает хранимые процедуры
• Не поддерживает несколько операторов
• Не поддерживает транзакции
• Не поддерживает все функции MySQL 5.1

Выше цитата из ответа Квентина

Отсутствие поддержки подготовленных операторов особенно важно, поскольку они обеспечивают более четкий и менее подверженный ошибкам метод экранирования и цитирования внешних данных, чем экранирование вручную с помощью отдельного вызова функции.

См. сравнение расширений SQL.

Подавление предупреждений об устаревании

Пока код преобразуется в MySQLi / PDO, ошибки E_DEPRECATED можно подавить, установив error_reporting в php.ini , чтобы исключить <65146756712567>

error_reporting = E_ALL ^ E_DEPRECATED

Обратите внимание, что это также скроет другие предупреждения об устаревании , которые, однако, могут относиться к другим вещам, кроме MySQL. ( из руководства по PHP )

Статья PDO против MySQLi: что вам следует использовать? >

И лучший способ - PDO, и сейчас я пишу простой PDO учебник.

$link = mysql_connect('localhost', 'user', 'pass');
mysql_select_db('testdb', $link);
mysql_set_charset('UTF-8', $link);

$db = new PDO('mysql:host=localhost;dbname=testdb;charset=utf8', 'username', 'password');

$db = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF-8', 
              'username', 
              'password',
              array(PDO::ATTR_EMULATE_PREPARES => false,
              PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION));

$db = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF-8', 
              'username', 
              'password');
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);

//Connected to MySQL
$result = mysql_query("SELECT * FROM table", $link) or die(mysql_error($link));

$stmt->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT );
$stmt->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING );
$stmt->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

try {
    //Connect as appropriate as above
    $db->query('hi'); //Invalid query!
} 
catch (PDOException $ex) {
    echo "An Error occured!"; //User friendly message/message you want to show to user
    some_logging_function($ex->getMessage());
}

function data_fun($db) {
    $stmt = $db->query("SELECT * FROM table");
    return $stmt->fetchAll(PDO::FETCH_ASSOC);
}

//Then later
try {
    data_fun($db);
}
catch(PDOException $ex) {
    //Here you can handle error and show message/perform action you want.
}

<?php
$result = mysql_query('SELECT * from table') or die(mysql_error());

$num_rows = mysql_num_rows($result);

while($row = mysql_fetch_assoc($result)) {
    echo $row['field1'];
}

<?php
$stmt = $db->query('SELECT * FROM table');

while($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
    echo $row['field1'];
}

<?php
$stmt = $db->query('SELECT * FROM table');
$results = $stmt->fetchAll(PDO::FETCH_ASSOC);

//Use $results

<?php
foreach($db->query('SELECT * FROM table') as $row) {
    echo $row['field1'];
}

 $stmt->fetch(PDO::FETCH_ASSOC)

<?php
$stmt = $db->query('SELECT * FROM table');
$row_count = $stmt->rowCount();
echo $row_count.' rows selected';

<?php
$result = $db->exec("INSERT INTO table(firstname, lastname) VAULES('John', 'Doe')");
$insertId = $db->lastInsertId();

<?php
$results = mysql_query("UPDATE table SET field='value'") or die(mysql_error());
echo mysql_affected_rows($result);

<?php
$affected_rows = $db->exec("UPDATE table SET field='value'");
echo $affected_rows;

 $stmt->bindParam(':bla', $bla);

<?php
$stmt = $db->prepare("SELECT * FROM table WHERE id=:id AND name=:name");
$stmt->execute(array(':name' => $name, ':id' => $id));
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);

class person {
    public $name;
    public $add;
    function __construct($a,$b) {
        $this->name = $a;
        $this->add = $b;
    }

}
$demo = new person('john','29 bla district');
$stmt = $db->prepare("INSERT INTO table (name, add) value (:name, :add)");
$stmt->execute((array)$demo);

<?php
$stmt = $db->prepare("INSERT INTO folks (name, add) values (?  ?)");
$stmt->bindValue(1, $name, PDO::PARAM_STR);
$stmt->bindValue(2, $add, PDO::PARAM_STR);
$stmt->execute();

$stmt = $db->prepare("INSERT INTO folks (name, add) values (?  ?)");
$stmt->execute(array('john', '29 bla district'));

$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
$pdo->query('SET NAMES GBK');
$stmt = $pdo->prepare("SELECT * FROM test WHERE name = ? LIMIT 1");
$stmt->execute(array(chr(0xbf) . chr(0x27) . " OR 1=1 /*"));

Во-первых, давайте начнем со стандартного комментария, который мы даем всем:

Пожалуйста, не используйте функции mysql_* в новом коде . Они больше не поддерживаются и официально признаны устаревшими. Смотрите красную рамку ? Узнайте о подготовленных операторах вместо этого и используйте PDO или MySQLi - - поможет вам решить, какая статья5 Если вы выберете PDO, вот хороший учебник.

Давайте рассмотрим это предложение за предложением и объясним:

• Они больше не обслуживаются и официально не поддерживаются

  Это означает, что сообщество PHP постепенно отказывается от поддержки этих очень старых функций. Скорее всего, их не будет в будущей (недавней) версии PHP! Продолжение использования этих функций может привести к поломке вашего кода в (не так уж) далеком будущем.

  НОВИНКА! - ext / mysql теперь официально устарел с PHP 5.5!

  Новее! ext / mysql был удален в PHP 7 .

• Вместо этого вы должны узнать о подготовленных операторах

  Расширение

  mysql_* не поддерживает подготовленные операторы , что (среди прочего) является очень эффективной контрмерой против SQL-инъекции . Он исправил очень серьезную уязвимость в приложениях, зависящих от MySQL, которая позволяет злоумышленникам получить доступ к вашему скрипту и выполнить любой возможный запрос к вашей базе данных.

  Для получения дополнительной информации см. Как я могу предотвратить SQL-инъекцию в PHP?

• Видите красную рамку?

  Когда вы переходите на любую страницу руководства по функциям mysql, вы видите красную рамку, поясняющую, что ее больше не следует использовать.

• Используйте PDO или MySQLi

  Существуют лучшие, более надежные и хорошо продуманные альтернативы, PDO - объект базы данных PHP , который предлагает полный подход ООП к взаимодействию с базой данных, и MySQLi , который является улучшением, специфичным для MySQL.

Потому что (среди прочего) гораздо сложнее обеспечить дезинфекцию входных данных. Если вы используете параметризованные запросы, как это делается с PDO или mysqli, вы можете полностью избежать риска.

Например, кто-то может использовать "enhzflep); drop table users" в качестве имени пользователя. Старые функции позволяют выполнять несколько операторов для каждого запроса, так что что-то вроде этого мерзкого баггера может удалить всю таблицу.

Если бы кто-то использовал PDO mysqli, имя пользователя было бы "enhzflep); drop table users".

См. bobby-tables.com.

Есть много причин, но, пожалуй, самая важная из них заключается в том, что эти функции поощряют небезопасные методы программирования, потому что они не поддерживают подготовленные операторы. Подготовленные операторы помогают предотвратить атаки с использованием SQL-инъекций.

При использовании функций mysql_* вы должны не забывать запускать параметры, задаваемые пользователем, через mysql_real_escape_string(). Если вы забудете только в одном месте или ускользнете только от части ввода, ваша база данных может подвергнуться атаке.

Использование подготовленных операторов в PDO или mysqli сделает такие ошибки программирования более сложными.

Функции mysql_:

1. устарели - они больше не обслуживаются
2. не позволяют легко перейти на другой сервер базы данных
3. не поддерживает подготовленные операторы, поэтому
4. поощрять программистов использовать конкатенацию для построения запросов, что приводит к уязвимостям SQL-инъекций