ugrás a tartalomhoz

PHP - error utf-8

inf · 2012. Május. 24. (Cs), 17.28
Php-ben tákolok, próbálok mindent utf-8-ra beállítani. Az egyedüli, amivel gondjaim vannak, hogy az error.log-ba nem utf-8-ban mennek bele az adatok, így pl az átadott paramétereknél az ékezetes karakterek helyett csupa kérdőjel van. Mondjuk ez inkább szépséghiba, de kíváncsi vagyok, hogy lehetséges e orvosolni valahogy?
‹ PHPandMYSQL login Trágár szürő ›
 ■
1

Nem kellene

janoszen · 2012. Május. 24. (Cs), 17.45
Az error logba mi írja az adatokat? Alapvetően nem kellene változnia semminek a logba íráskor, hacsak nincs közben valami elemző. Azt is vedd figyelembe, hogy annak a szoftvernek is UTF-8-ban kellene olvasnia az adatokat, amelyikkel nézed.
2

Hát netbeans elméletileg

inf · 2012. Május. 24. (Cs), 18.01
Hát netbeans elméletileg képes erre :D Az error.log-ba maga a php írja az adatokat, gondoltam valami ini beállítással lehetne konfigurálni, hogy ugyan már csinálja utf-8ban, de eddig nem találtam ilyet.
3

Milyen op.rendszeren? Nekem

eddig bírtam szó nélkül · 2012. Május. 24. (Cs), 18.39
Milyen op.rendszeren? Nekem valami ubuntu12 klónom van jelenleg (xubuntu), ezen az apache error_log-jába küldött UTF-8 kódolású, ékezetes karakterek így jelennek meg:

\xc3\x81rv\xc3\xadzt\xc5\xb1r\xc5\x91 T\xc3\xbck\xc3\xb6rf\xc3\xbar\xc3\xb3g\xc3\xa9p
(gyk: árvíztűrő tükörfúrógép :-))

Viszont az is tény, hogy ezen nem sikerült változtatnom az apache átkonfigurálásával. (feltéve, hogy jó helyen turkáltam)
4

Én win7 IIS -el tolom, nálam

inf · 2012. Május. 24. (Cs), 21.25
Én win7 IIS -el tolom, nálam kérdőjelek vannak, nem néztem meg, hogy melyik karaktert mi takar, nem érdekes... Közben kiderült, hogy a parse_url sem érti az utf-8-at :-) Vicces ez a php, elvileg netes nyelv, de megőszülsz, mire normálisan beállítod minden string függvényhez a karakterkódolást...
5

A vezérlőpultban állítsd át a

Karvaly84 · 2012. Május. 24. (Cs), 22.47
A vezérlőpultban állítsd át a alapértelmezett kódolást (mert win alat nem utf-8 a magyar nyelv esetén), szerintem az megoldja, bár windows-on még nem php-ztam még.
6

Valami ANSI bullshit az

inf · 2012. Május. 25. (P), 00.38
Valami ANSI bullshit az alapértelmezett, de annyira nem számít. Az utóbbi két napban kicsit elmerültem a php karakterkódolási hibái között. Egyelőre csak nagyjából átfutottam őket, nincsen rendesen letesztelve, de azért voltak vicces dolgok...

Amivel még gondban vagyok az az mb_split, mert pattern-t vár el, és nem stringet, emiatt, a split-tel és replace-el gondok vannak. Sajnos quote-olni sem lehet, mert nincs olyan mb függvény. Valszeg az lesz, hogy preg_split + qoute-al fogom valahogy megoldani mindkettőt. Elvileg be lehet configolni úgy a php-t, hogy az strtolower is működjön utf-8 szöveggel, viszont nekem valami olyasmi kéne, ami nem konfig függő...

<?php

if (!extension_loaded('mbstring') && !dl('mbstring'))
    throw new Exception('Extension mbstring required!');

class Clean_String_Manipulator {

    static protected $encoding = 'utf-8';
    static protected $regexFlag = 'u';

    static public function isEmpty($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        return $string === '';
    }

    static public function encodePattern($string) {
        return preg_quote($string);
    }

    static public function encodeCamelCase($string, $separator) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($separator))
            throw new InvalidArgumentException('Separator must be a string.');
        try {
            $chunks = self::split(self::toLowerCase($string), $separator);
            for ($index = 1, $length = count($chunks); $index < $length; ++$index)
                $chunks[$index] = self::upperCaseFirst($chunks[$index]);
            return self::concat($chunks, '');
        } catch (Exception $e) {
            throw new Exception('String camelize failed: ' . $e);
        }
    }

    static public function decodeCamelCase($string, $separator) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($separator))
            throw new InvalidArgumentException('Separator must be a string.');
        try {
            $escapedSeparator = self::replace($separator, '$', '\\$');
            $separated = self::replaceByPattern($string, '%(?!^)\p{Lu}%usD', $escapedSeparator . '$0');
            return self::toLowerCase($separated);
        } catch (Exception $e) {
            throw new Exception('String deCamelize failed: ' . $e);
        }
    }

    static public function encodeUrlComponents(array $components) {
        $url = '';
        if (isset($components['host']) && $components['host'] !== '') {
            if (isset($components['scheme']) && $components['scheme'] !== '')
                $url.=$components['scheme'] . '://';
            $url.=$components['host'];
            if (isset($components['port']) && !in_array($components['port'], array('', 80, 8080)))
                $url.=':' . $components['port'];
        }
        $url.='/';
        if (isset($components['path']) && $components['path'] !== '')
            $url.=$components['path'];
        if (isset($components['query']) && $components['query'] !== '')
            $url.='?' . $components['query'];
        if (isset($components['fragment']) && $components['fragment'] !== '')
            $url.='#' . $components['fragment'];
        return $url;
    }

    static public function decodeUrlComponents($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        $escaped = self::replaceByPattern($string, '%[^:/?#&=\.]+%sDe', 'urlencode(\'$0\')');
        $result = parse_url($escaped);
        if (!is_array($result))
            throw new Exception('String decodeUrlComponents failed.');
        foreach ($result as $key => $value)
            $result[$key] = urldecode($value);
        return $result;
    }

    static public function encodeUrl($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        $result = urlencode($string);
        if (!is_string($result))
            throw new Exception('String urlEncode failed.');
        return $result;
    }

    static public function decodeUrl($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        $result = urldecode($string);
        if (!is_string($result))
            throw new Exception('String urlEncode failed.');
        return $result;
    }

    static public function encodeQuery(array $data) {
        if (!is_array($data))
            throw new InvalidArgumentException('Data must be an array.');
        return http_build_query($data);
    }

    static public function decodeQuery($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (self::subString($string, 0, 1) == '?')
            $string = self::subString($string, 1, self::getLength($string));
        mb_parse_str($string, $data);
        return $data;
    }

    static public function subString($string, $start, $end) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_int($start))
            throw new InvalidArgumentException('Start must be an integer.');
        if (!is_int($end))
            throw new InvalidArgumentException('End must be an integer.');
        if ($end < $start)
            throw new InvalidArgumentException('Start cannot be bigger than end.');
        $result = mb_substr($string, $start, $end - $start, self::$encoding);
        if (!is_string($result))
            throw new Exception('String toUpperCase failed.');
        return $result;
    }

    static public function getLength($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        $result = mb_strlen($string, self::$encoding);
        if (!is_int($result))
            throw new Exception('String getLength failed.');
        return $result;
    }

    static public function replace($string, $search, $replacement) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($search))
            throw new InvalidArgumentException('Search must be a string.');
        if (!is_string($replacement))
            throw new InvalidArgumentException('Replacement must be a string.');
        $result = self::concat(self::split($string, $search), $replacement);
        if (!is_string($result))
            throw new Exception('String replace failed.');
        return $result;
    }

    static public function replaceByPattern($string, $pattern, $replacement) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($pattern))
            throw new InvalidArgumentException('Pattern must be a string.');
        if (!is_string($replacement))
            throw new InvalidArgumentException('Replacement must be a string.');
        $pattern .= self::$regexFlag;
        $result = preg_replace($pattern, $replacement, $string);
        if (!is_string($result))
            throw new Exception('String replaceByPattern failed.');
        return $result;
    }

    static public function matchFullByPattern($string, $pattern) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($pattern))
            throw new InvalidArgumentException('Pattern must be a string.');
        $pattern .= self::$regexFlag;
        preg_match($pattern, $string, $result);
        if (!isset($result) || !is_array($result))
            throw new Exception('String matchFullByPattern failed.');
        return $result;
    }

    static public function matchByPattern($string, $pattern) {
        try {
            $groups = self::matchFullByPattern($string, $pattern);
            return $groups[0];
        } catch (Exception $e) {
            throw new Exception('String matchByPattern failed: ' . $e);
        }
    }

    static public function matchGroupsByPattern($string, $pattern) {
        try {
            $groups = self::matchFullByPattern($string, $pattern);
            array_shift($groups);
            return $groups;
        } catch (Exception $e) {
            throw new Exception('String matchGroupsByPattern failed: ' . $e);
        }
    }

    static public function testByPattern($string, $pattern) {
        try {
            $groups = self::matchFullByPattern($string, $pattern);
            return empty($groups);
        } catch (Exception $e) {
            throw new Exception('String testByPattern failed: ' . $e);
        }
    }

    static public function split($string, $separator) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($separator))
            throw new InvalidArgumentException('Separator must be a string.');
        $result = mb_split($separator, $string);
        if (!is_array($result))
            throw new Exception('String split failed.');
        return $result;
    }

    static public function splitByPattern($string, $pattern) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($pattern))
            throw new InvalidArgumentException('Pattern must be a string.');
        $pattern .= self::$regexFlag;
        $result = preg_split($pattern, $string);
        if (!is_array($result))
            throw new Exception('String splitByPattern failed.');
        return $result;
    }

    static public function splitByPatternGroups($string, $pattern) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        if (!is_string($pattern))
            throw new InvalidArgumentException('Pattern must be a string.');
        $pattern .= self::$regexFlag;
        if ($keepCapturingGroups)
            $flagCode = PREG_SPLIT_DELIM_CAPTURE;
        else
            $flagCode = 0;
        $result = preg_split($pattern, $string, -1, PREG_SPLIT_DELIM_CAPTURE);
        if (!is_array($result))
            throw new Exception('String splitByPattern failed.');
        return $result;
    }

    static public function concat(array $chunks, $separator) {
        if (!is_string($separator))
            throw new InvalidArgumentException('Separator must be a string.');
        $result = implode($separator, $chunks);
        if (!is_string($result))
            throw new Exception('String concat failed.');
        return $result;
    }

    static public function toLowerCase($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        $result = mb_strtolower($string, self::$encoding);
        if (!is_string($result))
            throw new Exception('String toLowerCase failed.');
        return $result;
    }

    static public function toUpperCase($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        $result = mb_strtoupper($string, self::$encoding);
        if (!is_string($result))
            throw new Exception('String toUpperCase failed.');
        return $result;
    }

    static public function lowerCaseWords($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        try {
            $chunks = self::splitByPattern($string, '%(\s+)%sD', true);
            foreach ($chunks as $index => $chunk)
                $chunks[$index] = self::lowerCaseFirst($chunk);
            return self::concat($chunks, '');
        } catch (Exception $e) {
            throw new Exception('String lowerCaseWords failed: ' . $e);
        }
    }

    static public function upperCaseWords($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        try {
            $chunks = self::splitByPattern($string, '%(\s+)%sD', true);
            foreach ($chunks as $index => $chunk)
                $chunks[$index] = self::upperCaseFirst($chunk);
            return self::concat($chunks, '');
        } catch (Exception $e) {
            throw new Exception('String upperCaseWords failed: ' . $e);
        }
    }

    static public function lowerCaseFirst($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        try {
            return self::toLowerCase(self::subString($string, 0, 1)) . self::subString($string, 1, self::getLength($string));
        } catch (Exception $e) {
            throw new Exception('String lowerCaseFirst failed: ' . $e);
        }
    }

    static public function upperCaseFirst($string) {
        if (!is_string($string))
            throw new InvalidArgumentException('Subject must be a string.');
        try {
            return self::toUpperCase(self::subString($string, 0, 1)) . self::subString($string, 1, self::getLength($string));
        } catch (Exception $e) {
            throw new Exception('String upperCaseFirst failed: ' . $e);
        }
    }

}
7

PCRE

Poetro · 2012. Május. 25. (P), 06.52
A PCRE függvények támogatnak UTF-8-at, csak meg kell nekik mondani az u módosítóval.
8

Tisztában vagyok vele, azokat

inf · 2012. Május. 25. (P), 12.12
Azokat használom, az u módosítót meg automatikusan csapja hozzá a rendszer, így nem tudom elfelejteni... Azt hiszem a teljes %%flag részt is automatikusan fogom hozzáírni, mert mindig usD-t használok, nagyon ritka esetben meg e-t is.
(szerk: Azt hiszem ez nem megvalósítható, nem szereti, ha a % szerepel a mintában. A sima szöveget is csak úgy tudtam betrükközni, hogy preg_quote és a határolónak meg +-t választottam.)

Azt hiszem ezek egy része benne van a PEAR i18n csomagokban.